...
Pregătire interviuri

100 de întrebări de interviu pentru QA Engineer (manual + automation), cu răspunsuri

Întrebările care apar des la interviurile de QA Engineer (manual + automation), fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 51junior
  • 35mid
  • 14senior
  • 151 minde citit
Întrebări de interviu QA Engineer (manual + automation) cu răspunsuri

Un interviu pentru QA Engineer începe de obicei cu o discuție HR (motivație, experiență, așteptări), urmată de unul sau două interviuri tehnice. În partea tehnică ți se cer concepte de testare (niveluri, tipuri, tehnici de design al testelor), un exercițiu practic de tipul „cum ai testa acest formular” sau „scrie un bug report pentru ce vezi aici”, întrebări de SQL și API și, pentru rolurile cu automatizare, cod live sau o temă de casă cu Playwright ori Selenium. Uneori există și o discuție cu echipa, unde se urmărește cum comunici cu developerii și cu product ownerul.

La junior se verifică dacă înțelegi corect fundamentele, dacă gândești sistematic (cazuri pozitive, negative, limite) și dacă știi să descrii clar o problemă. La mid se așteaptă experiență reală: să proiectezi un test plan, să construiești și să întreții teste automate stabile, să lucrezi cu CI și să argumentezi ce testezi și ce nu. La senior conversația se mută spre strategie, risc, arhitectura frameworkului de automatizare și influența asupra calității întregii echipe.

Folosește pagina activ: citește întrebarea, răspunde cu voce tare înainte să deschizi răspunsul, apoi compară. Răspunsul scurt e ce ai spune în primele zece secunde, iar răspunsul detaliat îți dă argumentele și exemplele pe care le poți dezvolta dacă intervievatorul insistă. Rubrica „de ce se întreabă” îți arată ce greșeli fac des candidații.

Fundamente QA și ISTQB

1 Junior

Ce este testarea software și de ce este necesară?

Răspuns scurt: Testarea software este procesul de evaluare a unui produs pentru a găsi defecte și a verifica dacă îndeplinește cerințele și nevoile utilizatorilor. E necesară pentru a reduce riscul ca problemele să ajungă la clienți.

Testarea software înseamnă un set de activități prin care evaluăm un produs (cod, documente, aplicația care rulează) ca să găsim defecte, să obținem informații despre calitatea lui și să reducem riscul de eșec în producție. Nu înseamnă doar „apăs pe butoane”: include analiza cerințelor, proiectarea cazurilor de test, execuția, raportarea și verificarea corecturilor.

De ce e necesară:

  • oamenii greșesc, iar greșelile din cerințe, design sau cod devin defecte care pot produce eșecuri vizibile pentru utilizatori;
  • un defect găsit devreme costă mult mai puțin de reparat decât unul descoperit după lansare, când implică hotfix, comunicare cu clienții și uneori pierderi financiare sau de reputație;
  • unele domenii (bancar, medical, auto) au cerințe legale și de conformitate care cer dovezi de testare;
  • testarea oferă informații pentru decizii: putem lansa sau nu, care sunt riscurile rămase.

Un punct important pentru interviu: testarea nu poate demonstra că un produs nu are defecte. Ea reduce probabilitatea ca defectele nedescoperite să rămână în produs și oferă încredere, pe baza riscurilor asumate. De aceea un QA bun se gândește constant la ce e mai riscant de testat, nu încearcă să testeze absolut tot.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi testarea ca reducere de risc și furnizare de informații, nu ca „găsit bug-uri”. Greșeala tipică este afirmația că testarea garantează un produs fără bug-uri.

2 Junior

Care este diferența dintre Quality Assurance, Quality Control și testare?

Răspuns scurt: QA este orientat pe proces și previne defectele, QC este orientat pe produs și le detectează, iar testarea este o activitate concretă din QC prin care execuți și evaluezi produsul.

Cele trei noțiuni sunt folosite des ca sinonime, dar înseamnă lucruri diferite.

  • Quality Assurance (QA) se ocupă de proces: standarde, bune practici, review-uri, definiția lui „gata”, instruirea echipei. Scopul e prevenirea defectelor. Exemplu: echipa introduce obligatoriu code review și criterii de acceptare clare pentru fiecare user story.
  • Quality Control (QC) se ocupă de produs: verifică dacă rezultatul obținut respectă cerințele. Scopul e detectarea defectelor. Exemplu: verificarea unui build înainte de release.
  • Testarea este principala activitate de QC: proiectezi cazuri de test, le execuți, compari rezultatul real cu cel așteptat și raportezi diferențele.

O analogie simplă: într-o bucătărie, QA înseamnă rețete standardizate și reguli de igienă, QC înseamnă degustarea fiecărui fel înainte să plece la client, iar testarea este gustul propriu-zis.

În practică, titlul de „QA Engineer” acoperă toate trei. Un QA bun nu doar testează la final, ci participă la rafinarea cerințelor, propune îmbunătățiri de proces și ajută echipa să construiască din start un produs mai bun. Asta e diferența dintre a fi „cel care găsește bug-uri” și a fi responsabil cu calitatea alături de echipă.

Ce urmărește intervievatorul: Se verifică dacă știi că QA înseamnă și prevenție, nu doar execuție de teste. Mulți candidați spun că sunt „același lucru”.

3 Junior

Care sunt cele șapte principii ale testării din ISTQB?

Răspuns scurt: Testarea arată prezența defectelor, nu absența lor; testarea exhaustivă e imposibilă; testarea timpurie economisește timp și bani; defectele se grupează; testele se uzează; testarea depinde de context; absența defectelor nu garantează succesul.

Syllabusul ISTQB Foundation Level (versiunea 4.0, 2023) enumeră șapte principii. Merită să le știi cu un exemplu fiecare:

  • Testarea arată prezența defectelor, nu absența lor. Dacă n-ai găsit bug-uri, nu înseamnă că nu există.
  • Testarea exhaustivă este imposibilă. Un câmp de text acceptă practic infinite combinații, deci alegi teste pe baza riscului și a tehnicilor de design.
  • Testarea timpurie economisește timp și bani (shift-left). O ambiguitate prinsă la review-ul cerinței costă o discuție, nu un hotfix.
  • Defectele se grupează. Puține module conțin majoritatea defectelor, de obicei cele complexe sau schimbate des; acolo concentrezi efortul.
  • Testele se uzează (în versiunile mai vechi, „paradoxul pesticidului”). Aceleași teste repetate nu mai găsesc defecte noi, așa că le actualizezi și adaugi altele.
  • Testarea depinde de context. Un joc mobil și un sistem de plăți nu se testează la fel.
  • Eroarea absenței defectelor. Un produs fără bug-uri care nu rezolvă problema utilizatorului tot e un eșec.

La interviu nu e suficient să le recitești. Leagă-le de practică: de exemplu, „din cauza grupării defectelor, după ce găsesc mai multe bug-uri într-un modul, extind testarea exploratorie acolo”.

Ce urmărește intervievatorul: Întrebarea verifică pregătirea teoretică de bază, des cerută la junior. Greșeala tipică este enumerarea fără exemple sau confundarea principiilor între ele.

4 Junior

Care este diferența dintre verificare și validare?

Răspuns scurt: Verificarea răspunde la „construim produsul corect?”, adică respectă specificația. Validarea răspunde la „construim produsul potrivit?”, adică rezolvă nevoia reală a utilizatorului.

Verificarea confirmă că un produs de lucru respectă specificațiile. Se poate face și fără să rulezi aplicația: review de cerințe, review de cod, analiză statică, dar și teste care compară comportamentul cu specificația. Întrebarea este: „am construit ce scrie în cerință?”.

Validarea confirmă că produsul răspunde nevoii reale a utilizatorului, în contextul lui de folosire. Se face de obicei cu aplicația funcțională: testare de acceptanță, demo cu clientul, beta testing. Întrebarea este: „am construit ce îi trebuie de fapt utilizatorului?”.

Exemplu: cerința spune „parola trebuie să aibă minimum 8 caractere”. Verificarea confirmă că aplicația respinge parolele de 7 caractere și le acceptă pe cele de 8. Validarea poate descoperi că utilizatorii nu înțeleg de ce le e respinsă parola, pentru că mesajul de eroare apare abia după trimiterea formularului, iar mulți renunță la înregistrare. Produsul e conform cerinței, dar nu e potrivit.

Ambele contează. Poți avea un produs perfect verificat care eșuează la validare (cerința era greșită) sau invers. De aceea un QA bun pune întrebări despre cerință încă din rafinare, nu doar testează ce scrie.

Ce urmărește intervievatorul: Se verifică dacă distingi conformitatea cu specificația de valoarea pentru utilizator. Greșeala tipică este inversarea celor două definiții.

5 Junior

Care sunt nivelurile de testare și ce se urmărește la fiecare?

Răspuns scurt: Nivelurile clasice sunt testarea de componentă (unit), de integrare, de sistem și de acceptanță. Fiecare are alt obiect de test, alt mediu și de obicei alți responsabili.

Nivelurile de testare grupează activitățile după ce testezi și cât de mare e bucata de sistem:

  • Testare de componentă (unit): o funcție, o clasă, un modul izolat. O scriu de obicei developerii, cu unelte precum JUnit sau Jest, iar dependențele externe se înlocuiesc cu mock-uri.
  • Testare de integrare: interacțiunea dintre componente sau sisteme. Exemplu: serviciul de comenzi scrie corect în baza de date, aplicația primește răspunsul corect de la procesatorul de plăți. ISTQB distinge integrarea între componente și integrarea între sisteme.
  • Testare de sistem: aplicația completă, într-un mediu cât mai apropiat de producție, comparată cu cerințele funcționale și nefuncționale. Aici lucrează cel mai mult echipa de QA, manual și automat (de exemplu teste end-to-end).
  • Testare de acceptanță: confirmă că produsul e gata pentru utilizare. Include UAT (făcut de utilizatori sau client), acceptanță operațională, contractuală sau de reglementare, plus alpha și beta testing.

Ideea importantă: defectele găsite la nivelurile de jos sunt mai ieftine și mai ușor de localizat. Un test unitar care pică îți spune exact funcția cu problema, pe când un test end-to-end care pică poate avea zeci de cauze. De aici vine și piramida testelor: multe teste jos, puține sus.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi structura clasică și cine face ce. Greșeala tipică este confundarea testării de sistem cu cea de acceptanță.

6 Junior

Ce diferență este între testarea funcțională și cea nefuncțională? Dă exemple.

Răspuns scurt: Testarea funcțională verifică ce face sistemul, adică funcțiile descrise în cerințe. Testarea nefuncțională verifică cât de bine o face: performanță, securitate, uzabilitate, compatibilitate, fiabilitate.

Testarea funcțională răspunde la întrebarea „sistemul face ce trebuie?”. Verifici comportamentul descris în cerințe: login-ul acceptă credențiale corecte și respinge pe cele greșite, coșul calculează corect totalul, emailul de confirmare pleacă după comandă.

Testarea nefuncțională răspunde la „cât de bine face sistemul ce trebuie?”. Modelul de calitate ISO/IEC 25010 descrie caracteristicile, iar cele mai des întâlnite la interviu sunt:

  • performanță: timp de răspuns, comportament sub încărcare (load, stress);
  • securitate: acces neautorizat, injecții, expunerea datelor;
  • uzabilitate și accesibilitate: cât de ușor e de folosit, inclusiv de persoane cu dizabilități;
  • compatibilitate: diferite browsere, sisteme de operare, dispozitive;
  • fiabilitate: comportament la erori, recuperare după căderi;
  • mentenabilitate și portabilitate.

Exemplu pe aceeași funcție: la căutarea de produse, testul funcțional verifică că „laptop” întoarce laptopuri. Testul nefuncțional verifică că rezultatele apar repede chiar și când sute de utilizatori caută simultan, că pagina funcționează pe Safari mobil și că un cititor de ecran anunță numărul de rezultate.

Un detaliu bun de menționat: cerințele nefuncționale lipsesc des din user stories. Un QA care întreabă „care e timpul de răspuns acceptabil?” aduce valoare înainte să scrie vreun test.

Ce urmărește intervievatorul: Se verifică dacă ai o imagine completă a calității, nu doar a funcțiilor. Mulți candidați reduc nefuncționalul la „performanță”.

7 Junior

Explică testarea black box, white box și grey box.

Răspuns scurt: Black box testează pe baza specificației, fără a cunoaște codul. White box se bazează pe structura internă a codului. Grey box combină cele două: testezi din exterior, dar folosești cunoștințe parțiale despre implementare.

Diferența ține de cât știi despre interiorul sistemului când proiectezi testele.

  • Black box (testare bazată pe specificație): tratezi aplicația ca pe o cutie închisă. Pornești de la cerințe, user stories, documentație și verifici intrările și ieșirile. Tehnicile tipice sunt partiționarea în clase de echivalență, analiza valorilor limită, tabelele de decizie și tranziția de stări. Majoritatea testării manuale și end-to-end intră aici.
  • White box (testare bazată pe structură): proiectezi testele pornind de la cod, ca să acoperi instrucțiuni, ramuri (if/else), bucle sau căi. Se folosește mai ales la testele unitare și se măsoară cu metrici de acoperire precum statement coverage și branch coverage.
  • Grey box: testezi tot din exterior, dar folosești informații interne. De exemplu, după ce plasezi o comandă din interfață, verifici cu un query SQL că rândul din tabela de comenzi are statusul corect, sau știi că un anumit endpoint e apelat și îl inspectezi în tab-ul Network.

Ca QA, lucrezi cel mai des black box și grey box. Cunoașterea elementelor de white box te ajută totuși să discuți cu developerii despre acoperire și să înțelegi unde lipsesc teste unitare. Spune la interviu că folosești SQL și DevTools: arată exact abordarea grey box pe care o caută echipele.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi tehnicile asociate fiecărui tip. Greșeala tipică este să spui că white box e doar treaba developerilor și că nu te privește.

8 Junior

Care este diferența dintre smoke testing și sanity testing?

Răspuns scurt: Smoke testing verifică rapid, pe un build nou, că funcțiile critice merg și că build-ul merită testat mai departe. Sanity testing verifică punctual, după o corectură sau mică schimbare, că zona afectată funcționează logic.

Ambele sunt verificări rapide și superficiale, dar au scopuri diferite.

Smoke testing se face pe un build nou, înainte de testarea detaliată. Întrebarea este: „build-ul e suficient de stabil ca să merite testat?”. Acoperă lat, dar nu adânc: aplicația pornește, te poți autentifica, pagina principală se încarcă, poți adăuga un produs în coș și ajunge la checkout. Dacă smoke-ul pică, build-ul se respinge și nu mai pierzi timp cu el. Se automatizează des și rulează în CI după fiecare deploy pe mediul de test.

Sanity testing se face după o schimbare mică sau o corectură de bug. Întrebarea este: „schimbarea funcționează și are sens?”. Acoperă îngust, dar ceva mai adânc, doar zona atinsă. Exemplu: s-a reparat calculul taxei de livrare pentru comenzile peste un anumit prag; verifici câteva comenzi sub, la și peste prag, plus afișarea totalului. Adesea e nescriptat.

Pe scurt: smoke este lat și superficial, pentru întregul build; sanity este îngust și țintit, pentru o modificare. Merită să spui la interviu că terminologia variază de la o firmă la alta. Unele echipe numesc „sanity” ce altele numesc „smoke”, așa că e bine să clarifici ce înțelege echipa prin fiecare termen.

Ce urmărește intervievatorul: E o întrebare clasică la junior. Se verifică dacă știi momentul și scopul fiecăreia, iar greșeala tipică este confuzia dintre ele sau cu regresia.

9 Junior

Care este diferența dintre retesting și regression testing?

Răspuns scurt: Retesting (testarea de confirmare) verifică faptul că un bug raportat a fost reparat. Regression testing verifică faptul că schimbările recente nu au stricat funcționalități care mergeau înainte.

Retesting, numit în ISTQB testare de confirmare, înseamnă să rulezi din nou exact pașii din bug report după ce developerul a livrat corectura. Scopul e să confirmi că defectul nu mai apare. Are o țintă precisă: un bug anume. Dacă trece, închizi bug-ul; dacă nu, îl redeschizi cu detalii noi.

Regression testing caută efecte secundare neintenționate. Orice schimbare de cod (corectură, funcție nouă, refactorizare, actualizare de bibliotecă) poate strica ceva aparent fără legătură. Exemplu: se repară formatul datei în factură, iar exportul CSV al comenzilor începe să afișeze datele greșit, pentru că folosea aceeași funcție de formatare.

Diferențe practice:

  • retestingul se face pe teste care au picat; regresia pe teste care treceau;
  • retestingul nu se automatizează de obicei, fiind punctual; regresia se repetă la fiecare release și e principalul candidat pentru automatizare;
  • regresia poate fi completă sau selectivă, pe baza analizei de impact: ce module folosesc codul schimbat.

Ordinea uzuală: întâi confirmi corectura (retesting), apoi rulezi regresia pe zona afectată și pe fluxurile critice. Când explici asta la interviu, leagă regresia de automatizare: o suită de regresie rapidă în CI e una dintre cele mai valoroase investiții ale unei echipe.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că o corectură poate produce bug-uri în altă parte. Greșeala tipică este folosirea celor doi termeni ca sinonime.

10 Mid

Descrie procesul de testare (STLC). Ce sunt criteriile de intrare și de ieșire?

Răspuns scurt: Procesul de testare cuprinde planificarea, monitorizarea, analiza, proiectarea, implementarea, execuția și încheierea testării. Criteriile de intrare spun când poți începe o activitate, iar cele de ieșire când o poți considera terminată.

ISTQB descrie procesul de testare prin grupuri de activități care pot fi iterative și se suprapun, mai ales în Agile:

  • Planificare: obiective, abordare, resurse, calendar, riscuri.
  • Monitorizare și control: compari progresul cu planul și corectezi.
  • Analiză: ce testăm, pe baza cerințelor (condiții de test); aici găsești și ambiguitățile din cerințe.
  • Proiectare: cum testăm; scrii cazuri de test, alegi datele, identifici mediul necesar.
  • Implementare: pregătești datele, mediul, scripturile automate, ordinea de execuție.
  • Execuție: rulezi testele, compari rezultatul real cu cel așteptat, raportezi defecte.
  • Încheiere: raport final, lecții învățate, arhivarea testware-ului.

Criteriile de intrare (Definition of Ready, în Agile) spun când e rezonabil să începi: cerința e clară și aprobată, build-ul e livrat și a trecut de smoke, mediul de test și datele sunt disponibile.

Criteriile de ieșire (Definition of Done) spun când te poți opri: toate testele planificate au fost rulate, nu există defecte critice deschise, acoperirea cerințelor a atins nivelul convenit, riscurile rămase sunt documentate și acceptate.

Criteriile contează pentru că transformă discuțiile vagi („am testat destul?”) în decizii verificabile. La interviu, arată că le-ai folosit concret, nu doar că știi lista de faze.

Ce urmărește intervievatorul: Se verifică dacă ai o imagine structurată a muncii de testare și dacă știi să stabilești când e gata. Mulți candidați reduc procesul la „scriu și rulez teste”.

11 Mid

Ce este testarea statică și ce avantaje are față de testarea dinamică?

Răspuns scurt: Testarea statică evaluează produse de lucru fără să execute codul: review de cerințe, review de cod, analiză statică cu unelte. Găsește defecte mai devreme și mai ieftin, inclusiv tipuri pe care testarea dinamică nu le vede.

Testarea dinamică presupune rularea software-ului. Testarea statică examinează documente și cod fără să le execute. Exemple:

  • review de cerințe și user stories: cauți ambiguități, contradicții, cerințe lipsă sau netestabile („aplicația trebuie să fie rapidă” nu se poate testa);
  • review de cod, de obicei în pull requesturi;
  • analiză statică automată: linters (ESLint), SonarQube, verificarea tipurilor în TypeScript;
  • review de design, de cazuri de test sau de scripturi automate.

ISTQB descrie mai multe tipuri de review, de la informale la formale: review informal, walkthrough, review tehnic și inspecție, cea din urmă fiind cea mai structurată, cu roluri și metrici.

Avantajele:

  • defectele sunt găsite înainte de a fi implementate, deci costă mult mai puțin;
  • găsește defecte direct (o cerință contradictorie), nu doar efectele lor (un eșec la rulare);
  • prinde probleme pe care testarea dinamică le ratează: cod mort, variabile neinițializate, încălcări de standard, vulnerabilități cunoscute, specificații lipsă;
  • se poate face înainte să existe cod executabil.

Ca QA, cea mai valoroasă testare statică pe care o faci este rafinarea user stories. Întrebări ca „ce se întâmplă dacă utilizatorul nu are adresă salvată?” previn bug-uri care altfel ar fi apărut abia în testare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi testarea dincolo de execuția aplicației. Greșeala tipică este afirmația că QA intră în joc abia după ce codul e gata.

12 Senior

Ce înseamnă shift-left și shift-right în testare și cum le aplici într-o echipă?

Răspuns scurt: Shift-left înseamnă mutarea activităților de calitate cât mai devreme în ciclul de dezvoltare. Shift-right înseamnă folosirea informațiilor din producție (monitorizare, feature flags, canary) pentru a verifica produsul în condiții reale.

Shift-left pornește de la principiul că testarea timpurie economisește timp și bani. Concret, într-o echipă:

  • QA participă la rafinare și la sesiuni „three amigos”, unde se clarifică criteriile de acceptare înainte de implementare;
  • criteriile se scriu în format testabil, eventual în Gherkin, și devin teste automate;
  • developerii scriu teste unitare și de integrare, iar QA revizuiește ce acoperă;
  • analiza statică și testele rulează automat la fiecare pull request, nu doar înainte de release;
  • testele API pot fi scrise pe baza contractului înainte să existe interfața.

Shift-right recunoaște că niciun mediu de test nu reproduce perfect producția. Practici:

  • monitorizare și alertare (erori, latență), analiza logurilor;
  • lansări graduale: canary release, feature flags activate întâi pentru un procent mic de utilizatori;
  • teste sintetice care rulează periodic pe producție pe fluxuri critice;
  • A/B testing și analiza feedbackului real.

Ca senior, rolul tău e să echilibrezi cele două. Shift-left reduce numărul de defecte, shift-right reduce impactul celor care tot scapă. Un mod bun de a începe într-o echipă nouă: alegi un singur punct cu durere mare (de exemplu, bug-uri din cerințe neclare) și introduci o practică (three amigos), măsori efectul, apoi extinzi. Schimbările impuse brusc tuturor rareori rezistă.

Ce urmărește intervievatorul: Se verifică dacă gândești calitatea pe tot ciclul de viață și știi să introduci practici gradual. Greșeala tipică este să definești shift-left doar ca „automatizăm mai mult”.

Tehnici de design al testelor

13 Junior

Ce este partiționarea în clase de echivalență? Aplic-o pe un câmp „vârstă” care acceptă valori între 18 și 65.

Răspuns scurt: Împarți datele de intrare în grupuri pe care sistemul ar trebui să le trateze la fel și testezi o valoare din fiecare grup. Pentru vârsta 18–65: o clasă validă (18–65) și clase invalide (sub 18, peste 65, non-numeric, gol).

Partiționarea în clase de echivalență pornește de la ideea că, dacă o valoare dintr-un grup funcționează, celelalte din același grup se vor comporta la fel. Așa reduci numărul de teste fără să pierzi acoperire.

Pentru un câmp „vârstă” care acceptă numere întregi între 18 și 65:

  • clasa validă: 18–65, de exemplu valoarea 30;
  • clasă invalidă: sub 18, de exemplu 10;
  • clasă invalidă: peste 65, de exemplu 80;
  • clasă invalidă: numere negative, de exemplu -5 (unii o includ în „sub 18”, dar e util să o tratezi separat dacă validarea e diferită);
  • clasă invalidă: valori zecimale, de exemplu 25.5;
  • clasă invalidă: text, de exemplu „abc”;
  • clasă invalidă: câmp gol.

Regula din ISTQB: la clasele valide poți combina mai multe într-un test, dar clasele invalide le testezi separat, câte una pe test. Motivul: dacă trimiți simultan vârstă invalidă și email invalid, iar sistemul afișează eroare, nu știi care validare a funcționat; una dintre ele ar putea lipsi complet.

Partiționarea se combină aproape mereu cu analiza valorilor limită, pentru că defectele apar cel mai des la marginile claselor (17, 18, 65, 66). La interviu, merită să spui că pui întrebări despre cerință: „vârsta se calculează din data nașterii sau se introduce direct?”. Răspunsul schimbă complet clasele.

Ce urmărește intervievatorul: Este exercițiul clasic de design al testelor. Se verifică dacă identifici și clasele invalide și dacă știi regula de a nu combina clase invalide.

14 Junior

Ce este analiza valorilor limită și ce valori testezi pentru un interval 1–100?

Răspuns scurt: Testezi valorile de la marginile claselor de echivalență, unde apar cele mai multe defecte. Pentru 1–100, cu metoda cu două valori: 0, 1, 100, 101; cu metoda cu trei valori: 0, 1, 2, 99, 100, 101.

Analiza valorilor limită (Boundary Value Analysis) se aplică pe partiții ordonate, cum sunt numerele, datele sau lungimea unui text. Developerii greșesc des la margini: scriu < în loc de <= sau numără de la 0 în loc de 1. De aceea limitele au o probabilitate mai mare de defecte decât valorile din mijlocul intervalului.

ISTQB Foundation 4.0 descrie două variante:

  • cu două valori: pentru fiecare limită, testezi limita și vecinul cel mai apropiat din partiția alăturată. Pentru 1–100: 0, 1, 100, 101;
  • cu trei valori: limita și ambii vecini. Pentru 1–100: 0, 1, 2 și 99, 100, 101.

Varianta cu trei valori prinde mai multe defecte. Exemplu: dacă developerul a scris x == 1 în loc de x >= 1, testul cu 1 trece, iar 0 este respins corect, deci varianta cu două valori nu prinde defectul. Valoarea 2 îl prinde.

Exemplu de cod cu bug tipic:

JavaScript
function isValidQuantity(x) {
  return x > 1 && x <= 100; // bug: ar trebui x >= 1
}

Testul cu valoarea 1 ar pica, dezvăluind defectul, pe când un test cu 50 ar trece.

Limitele nu sunt doar numerice: lungimea maximă a unui câmp (255 vs 256 de caractere), data de azi vs ieri, primul și ultimul element dintr-o listă paginată, pragul la care se aplică un discount.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi exact ce valori alegi și de ce. Greșeala tipică este alegerea unor valori la întâmplare din interior sau uitarea vecinilor din afara intervalului.

15 Junior

Ce cazuri de test ai scrie pentru o pagină de login cu email și parolă?

Răspuns scurt: Aș acoperi fluxul pozitiv, cazurile negative (credențiale greșite, câmpuri goale, format invalid), securitatea (mesaje generice, blocare după încercări, parola mascată, HTTPS), uzabilitatea și accesibilitatea, plus comportamentul sesiunii.

E o întrebare de gândire, așa că structurează răspunsul pe categorii, nu enumera la întâmplare.

Funcțional, pozitiv

  • email și parolă corecte duc la autentificare și redirecționare spre pagina corectă;
  • emailul cu majuscule sau spații la capete e tratat conform cerinței;
  • „Ține-mă minte” păstrează sesiunea după închiderea browserului.

Funcțional, negativ

  • parolă greșită, email inexistent, ambele câmpuri goale, câte unul gol;
  • email cu format invalid (fără @, fără domeniu);
  • parola are sensibilitate la majuscule;
  • valori la lungimea maximă și peste ea.

Securitate

  • mesajul de eroare nu dezvăluie dacă emailul există („Email sau parolă incorecte”);
  • blocare sau CAPTCHA după un număr de încercări eșuate, conform cerinței;
  • parola e mascată și nu apare în URL sau în loguri;
  • pagina rulează doar pe HTTPS;
  • după logout, butonul Back nu redă acces la pagini protejate;
  • încercări simple de SQL injection în câmpuri.

Uzabilitate și accesibilitate

  • navigare cu Tab, trimitere cu Enter, etichete corecte pentru cititoarele de ecran;
  • link funcțional de „Am uitat parola”.

Compatibilitate: browsere principale și mobil.

Încheie spunând ce întrebări ai pune: există autentificare cu Google, autentificare în doi pași, care e politica de blocare. Intervievatorul apreciază mai mult structura și întrebările de clarificare decât o listă lungă.

Ce urmărește intervievatorul: Se verifică dacă gândești sistematic, inclusiv dincolo de cazurile pozitive. Greșeala tipică este să te oprești la „login corect” și „parolă greșită”.

16 Junior

Ce este testarea exploratorie și când o folosești?

Răspuns scurt: Testarea exploratorie înseamnă să înveți aplicația, să proiectezi și să execuți teste în același timp, ghidat de experiență și de ce observi. O folosești când cerințele sunt incomplete, timpul e scurt sau vrei să găsești ce scapă testelor scriptate.

În testarea scriptată scrii întâi cazurile de test, apoi le execuți. În testarea exploratorie proiectarea, execuția și învățarea se fac simultan: rezultatul unui pas îți sugerează următorul test. Nu e testare la întâmplare, ci gândire structurată în timp real.

Ca să fie eficientă, se organizează de obicei în sesiuni (session-based testing):

  • un charter, adică o misiune scurtă: „explorează aplicarea codurilor de reducere în coș, cu accent pe combinații și pe produse la ofertă”;
  • o durată fixă, de exemplu 60–90 de minute;
  • notițe: ce ai testat, ce ai observat, bug-uri, întrebări;
  • un scurt debrief la final.

Când o folosești:

  • funcție nouă, documentată slab, pe care trebuie s-o înveți repede;
  • timp limitat înainte de release;
  • completarea testelor automate, care verifică doar ce le-ai spus să verifice;
  • zone cu multe bug-uri recente.

Tehnicile înrudite: error guessing (folosești experiența ca să ghicești unde greșesc developerii: câmpuri goale, caractere speciale, dublu click pe „Plătește”, pierderea conexiunii) și atacurile de tip „tour”, unde parcurgi aplicația dintr-o anumită perspectivă.

La interviu, un exemplu concret ajută: „în timpul unei sesiuni pe checkout am dat dublu click pe butonul de plată și s-au creat două comenzi”.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că explorarea are structură (charter, timp, notițe). Greșeala tipică este s-o descrii ca „testare fără plan”.

17 Junior

Cum ai testa un lift?

Răspuns scurt: Aș clarifica întâi cerințele (etaje, capacitate, utilizatori), apoi aș grupa testele: funcționale (chemare, selectare etaj, uși), siguranță (supraîncărcare, obstacol în uși, pană de curent, alarmă), performanță, uzabilitate și accesibilitate.

Întrebările de tipul „cum ai testa un obiect” verifică modul de gândire, nu cunoștințele despre lifturi. Începe cu întrebări de clarificare: câte etaje are clădirea, ce capacitate are liftul, e pentru locuințe sau spital, există cerințe legale, câte lifturi lucrează împreună?

Apoi structurează pe categorii:

Funcțional

  • chemarea de la fiecare etaj, în sus și în jos;
  • selectarea etajului din cabină, inclusiv a etajului curent;
  • mai multe comenzi simultane: ordinea în care sunt servite;
  • ușile se deschid la sosire și se închid după un timp; butoanele de deschidere și închidere.

Siguranță, cea mai importantă categorie aici

  • supraîncărcare: liftul nu pornește și semnalizează;
  • obstacol între uși: ușile se redeschid;
  • pană de curent: ce se întâmplă cu persoanele din cabină;
  • butonul de alarmă și interfonul funcționează.

Valori limită: greutatea exact la capacitate și puțin peste, primul și ultimul etaj.

Performanță: timpul de așteptare la ore de vârf, viteza.

Uzabilitate și accesibilitate: butoane în Braille, semnale sonore, înălțimea panoului, afișajul etajului.

Fiabilitate: funcționarea continuă pe durate lungi.

Încheie cu prioritizarea: aș începe cu siguranța, pentru că acolo un defect are cel mai mare impact. Asta arată gândire bazată pe risc, exact ce caută intervievatorul.

Ce urmărește intervievatorul: Se verifică structura gândirii, întrebările de clarificare și prioritizarea după risc. Greșeala tipică este enumerarea haotică a câtorva teste funcționale.

18 Mid

Ce este un tabel de decizie și când îl folosești? Dă un exemplu.

Răspuns scurt: Un tabel de decizie arată toate combinațiile de condiții și acțiunea rezultată pentru fiecare. Îl folosești când regulile de business depind de mai multe condiții combinate, ca să nu ratezi combinații.

Tabelele de decizie sunt utile când comportamentul sistemului depinde de combinații de condiții, nu de o singură valoare. Fiecare coloană e o regulă (o combinație), iar fiecare regulă devine cel puțin un caz de test.

Exemplu: un magazin online oferă livrare gratuită dacă clientul are cont premium SAU coșul depășește 200 de lei, dar nu pentru produsele voluminoase.

Condiții                 R1  R2  R3  R4  R5  R6  R7  R8
Cont premium             D   D   D   D   N   N   N   N
Coș peste 200 lei        D   D   N   N   D   D   N   N
Produs voluminos         D   N   D   N   D   N   D   N
Acțiune:
Livrare gratuită         N   D   N   D   N   D   N   N

Cu trei condiții binare ai 2 la puterea 3, adică 8 combinații. Tabelul complet te obligă să răspunzi la fiecare: ce se întâmplă cu un client premium cu produs voluminos? Adesea cerința nu spune, iar tabelul scoate la iveală golul înainte de implementare.

Când numărul de combinații crește, tabelul se poate minimiza: regulile în care o condiție nu influențează rezultatul se comasează, notate cu „–”. Aici, R1, R3, R5 și R7 au același rezultat oricare ar fi celelalte condiții, deci „produs voluminos = D” implică „nu” indiferent de rest.

Avantajul principal la interviu: tabelul de decizie e și o unealtă de comunicare cu product ownerul, nu doar o tehnică de test.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți modela reguli de business complexe. Greșeala tipică este testarea doar a câtorva combinații „evidente”.

19 Mid

Ce este testarea prin tranziție de stări? Dă un exemplu dintr-o aplicație reală.

Răspuns scurt: Modelezi sistemul ca un set de stări și de evenimente care îl mută dintr-o stare în alta, apoi testezi tranzițiile valide și pe cele invalide. E potrivită pentru comenzi, conturi, fluxuri de aprobare.

Multe sisteme se comportă diferit în funcție de starea în care se află. Testarea prin tranziție de stări folosește o diagramă sau un tabel cu stări, evenimente (ce declanșează schimbarea), tranziții și eventual condiții (guards).

Exemplu: ciclul de viață al unei comenzi online.

Nouă --plată reușită--> Plătită
Nouă --plată eșuată--> Nouă (maxim 3 încercări)
Nouă --anulare--> Anulată
Plătită --expediere--> Expediată
Plătită --anulare--> Anulată (cu rambursare)
Expediată --livrare--> Livrată
Livrată --retur în 14 zile--> Returnată

Ce testezi:

  • tranzițiile valide: fiecare săgeată cel puțin o dată (acoperirea tuturor tranzițiilor e criteriul uzual);
  • tranzițiile invalide: evenimente care nu ar trebui să fie permise într-o stare. Poți anula o comandă expediată? Poți plăti a doua oară o comandă deja plătită? Aici apar multe bug-uri grave;
  • condițiile: a patra plată eșuată, returul în ziua 15;
  • secvențe mai lungi, de exemplu plată, anulare, rambursare, apoi încercare de expediere.

Un tabel de stări (stări pe rânduri, evenimente pe coloane) te ajută să vezi explicit fiecare combinație stare–eveniment, inclusiv pe cele invalide, care lipsesc din diagramă.

Alte exemple bune: contul de utilizator (activ, blocat după încercări eșuate, suspendat, șters), un tichet de suport, un automat de cafea.

Ce urmărește intervievatorul: Se verifică dacă știi să testezi și tranzițiile interzise, nu doar fluxul fericit. Greșeala tipică este ignorarea combinațiilor invalide stare–eveniment.

20 Mid

Ce este pairwise testing și când merită folosit?

Răspuns scurt: Pairwise testing alege un set redus de combinații astfel încât fiecare pereche de valori a oricăror doi parametri apare cel puțin o dată. Merită când ai mulți parametri cu multe valori și testarea tuturor combinațiilor e nerealistă.

Să zicem că trebuie să testezi o aplicație web pe combinații de: browser (Chrome, Firefox, Safari), sistem de operare (Windows, macOS, Linux), limbă (RO, EN) și tip de cont (gratuit, premium). Toate combinațiile înseamnă 3 × 3 × 2 × 2 = 36 de teste. Cu mai mulți parametri, numărul explodează.

Pairwise (testarea pe perechi, o formă de testare combinatorială) se bazează pe observația că multe defecte sunt declanșate de un singur parametru sau de interacțiunea a doi parametri, mult mai rar de trei sau mai mulți. Așa că alegi un set de teste în care fiecare pereche posibilă (Chrome cu Linux, Safari cu premium, EN cu Windows etc.) apare măcar o dată. Pentru exemplul de mai sus ajung în jur de 9–10 teste în loc de 36.

Setul nu se calculează de mână. Se folosesc unelte precum PICT (de la Microsoft, open source) sau generatoare online. În PICT definești parametrii într-un fișier text și poți adăuga constrângeri, de exemplu că Safari rulează doar pe macOS.

Limitări de menționat:

  • nu prinde defectele care apar doar la o combinație de trei factori;
  • combinațiile critice pentru business le adaugi explicit, chiar dacă sunt deja acoperite;
  • funcționează bine pentru configurații, formulare cu multe opțiuni, parametri de API.

Spune la interviu că pairwise reduce costul, dar nu înlocuiește judecata despre risc.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să controlezi explozia combinatorială. Greșeala tipică este afirmația că pairwise garantează găsirea tuturor defectelor.

21 Senior

Ai două zile până la release și nu poți testa tot. Cum decizi ce testezi?

Răspuns scurt: Folosesc testare bazată pe risc: evaluez probabilitatea și impactul unei defecțiuni pentru fiecare zonă, încep cu fluxurile critice și schimbările recente, comunic transparent ce rămâne netestat și las decizia de risc echipei și product ownerului.

Răspunsul bun este testarea bazată pe risc. Riscul este o combinație între probabilitatea ca ceva să se strice și impactul dacă se strică.

Pașii pe care i-aș urma:

  • Listez zonele afectate de release: funcții noi, bug-uri reparate, module atinse indirect (analiză de impact cu developerii, eventual pe baza diff-ului).
  • Evaluez probabilitatea: cod nou sau complex, module cu istoric de bug-uri, schimbări de ultim moment, integrări externe.
  • Evaluez impactul: bani (plăți, facturare), date (pierdere, corupere), securitate, conformitate legală, numărul de utilizatori afectați.
  • Prioritizez: întâi zonele cu risc mare pe ambele axe. Fluxurile critice (login, checkout, plată) intră aproape mereu.
  • Aleg abordarea: rulez suita automată de regresie pentru acoperire largă, iar timpul manual îl pun în testare exploratorie țintită pe funcțiile noi.
  • Comunic: la final spun clar ce am testat, ce nu și ce riscuri rămân. Decizia de lansare cu riscuri cunoscute aparține echipei și product ownerului, nu doar QA.

Pe termen lung, situația arată și o problemă de proces: dacă testarea e constant comprimată la final, propun măsuri precum testarea în paralel cu dezvoltarea, automatizarea regresiei sau limitarea muncii în curs. La nivel senior, intervievatorul vrea să audă și această parte, nu doar cum supraviețuiești unui release.

Ce urmărește intervievatorul: Se verifică maturitatea: prioritizare argumentată și comunicare transparentă a riscului. Greșeala tipică este „stau peste program și testez tot” sau ascunderea a ceea ce nu s-a testat.

22 Senior

Cum măsori acoperirea testelor? Ce înseamnă statement coverage și branch coverage?

Răspuns scurt: Acoperirea se măsoară față de cerințe (câte cerințe au teste), față de risc și față de cod. Statement coverage arată procentul de instrucțiuni executate de teste, iar branch coverage procentul de ramuri de decizie executate.

Acoperirea răspunde la întrebarea „cât din ceva am testat?”, iar acel „ceva” poate fi diferit:

  • acoperirea cerințelor: câte cerințe sau criterii de acceptare au cel puțin un test, de obicei urmărită printr-o matrice de trasabilitate;
  • acoperirea riscurilor: câte riscuri identificate au teste asociate;
  • acoperirea codului: ce parte din cod e executată de teste, măsurată cu unelte (JaCoCo pentru Java, Istanbul sau c8 pentru JavaScript).

Pentru cod, două metrici apar des:

JavaScript
function discount(total, isPremium) {
  let d = 0;
  if (isPremium) {
    d = 10;
  }
  return total - d;
}

Un singur test cu isPremium = true execută toate instrucțiunile: 100% statement coverage. Dar ramura în care condiția e falsă nu a fost executată, deci branch coverage este 50%. Pentru 100% branch coverage ai nevoie și de un test cu isPremium = false. Branch coverage complet implică statement coverage complet, invers nu.

Ce merită spus la nivel senior:

  • acoperirea mare nu înseamnă teste bune. Poți executa tot codul fără nicio aserțiune. Mutation testing (de exemplu Stryker pentru JavaScript) verifică dacă testele chiar prind modificări în cod;
  • ținta de acoperire se stabilește pe risc, nu uniform: codul de plăți merită mai mult decât o pagină de prezentare;
  • folosesc acoperirea ca să găsesc zone netestate, nu ca scop în sine. Când o metrică devine țintă, oamenii scriu teste ca s-o umfle.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi limitele metricilor de acoperire. Greșeala tipică este echivalarea unui procent mare cu o calitate mare.

Bug-uri și documentația de test

23 Junior

Ce conține un bug report bun?

Răspuns scurt: Un titlu clar și specific, pașii exacți de reproducere, rezultatul așteptat și cel obținut, mediul (build, browser, sistem, cont de test), severitatea, plus dovezi: capturi, înregistrări video, loguri, request-uri din Network.

Un bug report bun permite oricui din echipă să reproducă problema fără să te întrebe nimic. Elementele uzuale:

  • Titlu: scurt și specific, care descrie problema și locul ei. Rău: „Checkout nu merge”. Bun: „Checkout: totalul nu include taxa de livrare când se aplică un cod de reducere”.
  • Precondiții: tip de cont, date necesare, setări.
  • Pași de reproducere: numerotați, câte o acțiune pe pas, cu datele exacte folosite.
  • Rezultat așteptat și rezultat obținut, separat. Rezultatul așteptat trimite, ideal, la cerință.
  • Mediu: versiunea sau build-ul, mediul (test, staging), browserul și versiunea, sistemul de operare, dispozitivul.
  • Severitate și eventual prioritate propusă.
  • Frecvență: apare mereu sau intermitent (de exemplu, de 3 ori din 10 încercări).
  • Atașamente: captură de ecran cu zona marcată, video scurt, erori din consolă, request-ul și răspunsul din tab-ul Network, ID-ul comenzii sau al utilizatorului, ora exactă pentru căutarea în loguri.

Câteva reguli bune:

  • un bug per raport;
  • descrii fapte, nu atribui vina („developerul a uitat”);
  • înainte să raportezi, cauți dacă nu există deja un raport (evitarea duplicatelor);
  • încerci să izolezi cauza: apare și fără codul de reducere? Și pe alt browser? Asta economisește mult timp developerului.

La interviu poți primi un exemplu concret și ți se poate cere să scrii raportul pe loc, deci exersează formatul.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente întrebări la junior. Se verifică claritatea și dacă incluzi mediul și dovezile; greșeala tipică este un titlu vag și pași incompleți.

24 Junior

Care este diferența dintre severitate și prioritate? Dă exemple pentru fiecare combinație.

Răspuns scurt: Severitatea arată cât de grav afectează defectul funcționarea sistemului, iar prioritatea arată cât de repede trebuie reparat. Severitatea o propune de obicei QA, prioritatea o decide product ownerul sau echipa.

Severitatea descrie impactul tehnic al defectului asupra sistemului: aplicația se blochează, se pierd date, o funcție nu merge deloc sau e doar o problemă cosmetică. Prioritatea descrie urgența reparării din punct de vedere al business-ului și al planificării.

Cele două sunt de obicei corelate, dar nu mereu. Exemplele pentru fiecare combinație sunt exact ce se cere la interviu:

  • Severitate mare, prioritate mare: plata cu cardul eșuează pentru toți utilizatorii. Se repară imediat.
  • Severitate mică, prioritate mare: numele firmei sau logo-ul e greșit pe pagina principală, chiar înainte de o campanie. Funcțional nu afectează nimic, dar afectează imaginea, deci se repară repede.
  • Severitate mare, prioritate mică: aplicația se blochează când exporți un raport cu peste un anumit număr de rânduri dintr-un modul folosit de câțiva administratori interni, care au și o soluție alternativă. Grav tehnic, dar poate aștepta sprintul următor.
  • Severitate mică, prioritate mică: o greșeală de aliniere într-o pagină de setări rar folosită.

Cine decide: QA propune severitatea, pe baza impactului observat. Prioritatea o stabilește de regulă product ownerul sau echipa, pentru că depinde de calendar, clienți, contracte și alte priorități. Un QA bun oferă informațiile necesare pentru decizie, de exemplu câți utilizatori sunt afectați și dacă există soluție alternativă.

Scalele diferă de la o echipă la alta (Blocker, Critical, Major, Minor, Trivial e una frecventă), deci adaptează-te la convenția proiectului.

Ce urmărește intervievatorul: Întrebare clasică la junior. Se verifică dacă știi să dai exemple pentru combinațiile „încrucișate”, unde candidații se blochează cel mai des.

25 Junior

Descrie ciclul de viață al unui bug.

Răspuns scurt: Un bug trece de obicei prin stările Nou, Asignat, În lucru, Reparat, Retest, apoi Închis sau Redeschis. Pe parcurs poate fi marcat și Respins, Duplicat, Amânat sau Nu se poate reproduce.

Ciclul de viață al unui defect (bug life cycle) descrie stările prin care trece din momentul raportării până la închidere. Denumirile exacte depind de unealta (Jira, Azure DevOps) și de configurarea echipei, dar fluxul tipic arată așa:

  • Nou: QA a creat raportul.
  • Triat / Asignat: echipa sau un lead a analizat raportul, i-a stabilit prioritatea și l-a dat unui developer.
  • În lucru: developerul investighează și repară.
  • Reparat / Rezolvat: corectura e făcută și livrată pe un build.
  • Retest / În testare: QA verifică pe build-ul nou.
  • Închis: corectura e confirmată, eventual după regresie pe zona afectată.
  • Redeschis: problema apare în continuare; bug-ul se întoarce la developer, cu detalii noi.

Stări alternative frecvente:

  • Respins / Nu e bug: comportamentul e conform cerinței;
  • Duplicat: există deja un raport, iar cele două se leagă;
  • Amânat: bug real, dar reparat mai târziu, după decizia de prioritate;
  • Nu se poate reproduce: developerul nu reușește să-l reproducă și cere mai multe informații.

Câteva bune practici: doar QA sau persoana care a raportat închide bug-ul după verificare; la redeschidere adaugi informații noi, nu doar schimbi statusul; când un bug e respins, discuți pe baza cerinței și, dacă cerința e ambiguă, implici product ownerul. Fluxul nu e o birocrație, ci un mod de a ști în orice moment ce se întâmplă cu fiecare problemă.

Ce urmărește intervievatorul: Se verifică familiaritatea cu procesul real dintr-o unealtă precum Jira. Greșeala tipică este omiterea stărilor alternative (duplicat, respins, amânat).

26 Junior

Un developer îți spune că bug-ul raportat „nu e bug, e feature” sau că „la mine merge”. Ce faci?

Răspuns scurt: Rămân pe fapte: verific cerința și criteriile de acceptare, compar mediile, ofer dovezi și îl ajut să reproducă problema. Dacă cerința e ambiguă, implic product ownerul să decidă comportamentul corect.

Situația e foarte frecventă, iar intervievatorul vrea să vadă că o tratezi profesionist, fără conflict.

Când developerul spune „nu e bug, e feature”:

  • verific cerința, criteriile de acceptare și designul. Dacă scrie clar comportamentul așteptat, i-l arăt;
  • dacă cerința nu acoperă situația, nu insist că am dreptate: e o ambiguitate, iar decizia aparține product ownerului. Îl implic, iar rezultatul se documentează în cerință;
  • uneori developerul are dreptate. Atunci închid raportul și notez că trebuie actualizate testele.

Când spune „la mine merge”:

  • compar mediile: build și versiune, mediu (local vs test), browser, date de test, rolul utilizatorului, setările de limbă, cache, feature flags;
  • îi trimit dovezi concrete: video, request-ul și răspunsul din Network, erorile din consolă, ID-ul entității, ora pentru loguri;
  • propun să reproducem împreună, pe ecranul meu sau pe mediul meu. De multe ori diferența apare în primele minute;
  • verific dacă problema e legată de date: contul meu poate avea o stare pe care contul lui nu o are.

Principiul de bază: obiectivul comun e produsul, nu cine are dreptate. Formulez raportul despre comportament, nu despre persoană, și păstrez tonul neutru. Când diferența de opinie persistă, o escaladez calm către lead sau product owner, cu faptele adunate.

Ce urmărește intervievatorul: Se verifică abilitățile de comunicare și metoda de lucru cu dovezi. Greșeala tipică este tonul defensiv sau renunțarea imediată fără investigare.

27 Junior

Care este diferența dintre test case, test scenario și checklist?

Răspuns scurt: Un test scenario descrie pe scurt ce funcționalitate testezi, un test case detaliază pașii, datele și rezultatul așteptat pentru o verificare anume, iar un checklist este o listă scurtă de verificări fără pași detaliați.

Sunt trei niveluri de detaliu pentru documentarea testării.

Test scenario (scenariu de test): o descriere de nivel înalt a ce vrei să verifici. Exemplu: „Verifică aplicarea codurilor de reducere în coș”. Un scenariu se descompune de obicei în mai multe cazuri de test. E util la planificare și ca să vezi rapid acoperirea.

Test case (caz de test): o verificare concretă, cu tot ce trebuie ca să o execuți repetabil:

  • ID și titlu;
  • precondiții;
  • date de test;
  • pași;
  • rezultat așteptat;
  • eventual prioritate și legătură cu cerința.

Exemplu: „Codul de reducere expirat este respins cu mesajul «Codul a expirat»”, cu pașii exacți și codul folosit.

Checklist: o listă de verificări scurte, fără pași detaliați. Exemplu, pentru o pagină nouă: titlul e corect, linkurile funcționează, pagina se afișează corect pe mobil, nu există erori în consolă. Presupune că testerul cunoaște aplicația.

Când alegi fiecare:

  • test cases detaliate pentru zone critice, pentru reglementări (unde ai nevoie de dovezi), pentru testeri noi în proiect și pentru tot ce urmează să fie automatizat;
  • checklisturi și scenarii în echipe Agile cu oameni care cunosc bine produsul, unde documentația detaliată ar costa mai mult decât ar aduce.

Un răspuns matur arată că nivelul de detaliu e o decizie de cost și beneficiu, nu o regulă fixă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferențele de detaliu și când folosești fiecare. Greșeala tipică este să spui că cele trei sunt același lucru.

28 Junior

Cum arată un caz de test bine scris? Scrie unul pentru resetarea parolei.

Răspuns scurt: Un caz de test bun are un titlu clar, precondiții, date de test, pași atomici și un rezultat așteptat verificabil. Verifică un singur lucru și poate fi executat la fel de oricine.

Caracteristicile unui caz de test bun:

  • verifică un singur lucru, ca la eșec să știi exact ce nu merge;
  • e repetabil: oricine din echipă îl execută la fel și obține același rezultat;
  • are rezultat așteptat verificabil, nu „funcționează corect”;
  • e independent de alte cazuri, pe cât posibil;
  • e legat de o cerință, pentru trasabilitate.

Exemplu:

ID: TC-PWD-004
Titlu: Linkul de resetare a parolei expiră după perioada stabilită
Cerință: US-112, criteriul 3 (linkul e valabil 30 de minute)
Prioritate: Mare
Precondiții:
- Există utilizatorul test.reset@example.com, activ
- Ai acces la căsuța de email de test
Pași:
1. Deschide pagina de login și apasă „Am uitat parola”
2. Introdu test.reset@example.com și apasă „Trimite”
3. Așteaptă 31 de minute (sau modifică data generării tokenului în baza de date de test)
4. Deschide linkul din email
Rezultat așteptat:
- Se afișează mesajul „Linkul a expirat. Cere unul nou.”
- Formularul de parolă nouă nu este afișat
- Parola veche funcționează în continuare

Observă două detalii: pasul 3 oferă o alternativă practică, pentru că așteptarea reală e costisitoare, iar rezultatul așteptat conține mai multe verificări ale aceleiași idei, nu teste diferite.

Alte cazuri pentru aceeași funcție ar fi: email inexistent (mesaj generic, din motive de securitate), linkul folosit a doua oară, parola nouă care nu respectă regulile, sesiunile active închise după resetare.

Ce urmărește intervievatorul: Se verifică dacă știi să scrii pe loc un caz de test clar și verificabil. Greșeala tipică este rezultatul așteptat vag sau mai multe verificări diferite în același caz.

29 Junior

Ce informații poți colecta din DevTools-ul browserului atunci când raportezi un bug?

Răspuns scurt: Din Console iau erorile JavaScript, din Network request-urile, codurile de stare, payload-urile și timpii de răspuns, din Application cookie-urile și local storage, iar din Elements structura și stilurile elementelor. Toate fac un bug report mult mai util.

DevTools (F12 în Chrome, Edge, Firefox) e una dintre cele mai utile unelte pentru un tester de aplicații web. Tab-urile principale:

  • Console: erori și avertismente JavaScript. O eroare de tipul TypeError: Cannot read properties of undefined lângă momentul defectului îi spune developerului exact unde să caute.
  • Network: toate request-urile făcute de pagină. Vezi metoda, URL-ul, codul de stare (de exemplu 500 sau 404), headerele, payload-ul trimis și răspunsul primit, plus timpii. Poți afla rapid dacă problema e în frontend (răspunsul e corect, dar afișarea e greșită) sau în backend (răspunsul conține deja date greșite). Click dreapta pe request oferă „Copy as cURL”, util pentru reproducere, iar întreaga sesiune se poate exporta ca fișier HAR.
  • Application: cookie-uri, local storage, session storage. Utile la probleme de sesiune, de autentificare sau de preferințe salvate.
  • Elements: structura HTML și CSS-ul aplicat; vezi de ce un element e ascuns sau suprapus.
  • Device toolbar: simularea ecranelor de mobil și a vitezelor de rețea lente (throttling).
  • Lighthouse: audit rapid de performanță, accesibilitate și bune practici.

Atenție la un detaliu de securitate: fișierele HAR și cURL copiat pot conține tokenuri de autentificare și cookie-uri. Înainte să le atașezi la un tichet vizibil pentru mulți oameni, elimini datele sensibile.

Folosirea DevTools transformă un raport „pagina nu se încarcă” într-unul cu cauza aproape identificată.

Ce urmărește intervievatorul: Intervievatorul verifică dacă faci investigație tehnică dincolo de interfață. Greșeala tipică este necunoașterea tab-ului Network.

30 Mid

Ai găsit un bug pe care nu reușești să-l reproduci a doua oară. Cum procedezi?

Răspuns scurt: Notez imediat tot ce știu (pași, date, oră, mediu), caut indicii în loguri și în Network, încerc variații sistematice (date, timing, browser, rețea) și, dacă tot nu se reproduce, îl raportez marcat ca intermitent, cu toate dovezile.

Bug-urile intermitente sunt frustrante, dar adesea sunt și cele mai grave: condiții de concurență, probleme de cache, defecte dependente de date sau de timp.

Pașii mei:

  • Notez imediat ce am făcut, ora exactă, datele folosite, contul, browserul, build-ul. Memoria se pierde repede.
  • Caut dovezi: înregistrarea ecranului dacă rulam una, erorile din consolă, request-urile din Network, logurile serverului din momentul respectiv (cu ajutorul developerului sau prin unealta de logging a echipei, de exemplu Kibana sau Grafana Loki), ID-ul de corelare al request-ului dacă aplicația îl expune.
  • Variez sistematic o singură variabilă odată:
  • viteza: click foarte rapid, dublu click, rețea lentă simulată în DevTools;
  • datele: alt utilizator, alt produs, valori la limite;
  • starea: sesiune nouă vs veche, cache golit, mai multe tab-uri deschise;
  • mediul: alt browser, alt dispozitiv;
  • timpul: aproape de miezul nopții, schimbare de lună, alt fus orar.
  • Caut tipare: dacă apare de 2 ori din 10, ce aveau în comun cele 2?

Dacă nu reușesc, raportez totuși bug-ul, marcat ca intermitent, cu frecvența observată și toate dovezile. Un raport onest „am văzut asta o dată, iată ce știu” e mai util decât tăcerea, mai ales pentru defecte grave precum plăți duplicate. Echipa poate decide să adauge loguri suplimentare ca să-l prindă data viitoare.

Ce urmărește intervievatorul: Se verifică metoda de investigație și onestitatea în raportare. Greșeala tipică este ignorarea bug-ului pentru că „nu se mai reproduce”.

31 Mid

Ce conține un test plan și cum îl adaptezi într-un proiect Agile?

Răspuns scurt: Un test plan descrie obiectivele, scopul (ce intră și ce nu), abordarea, mediile, resursele, calendarul, criteriile de intrare și ieșire, riscurile și livrabilele. În Agile devine de obicei un document scurt, viu, completat de planificarea pe sprint.

Test planul răspunde la întrebările: ce testăm, cum, cine, cu ce, când și de unde știm că am terminat. Standardul ISO/IEC/IEEE 29119-3 (care a înlocuit IEEE 829) descrie structura, iar elementele uzuale sunt:

  • context și obiective: produsul, release-ul, ce urmărim;
  • scop: ce funcționalități intră și, la fel de important, ce nu intră;
  • abordare: niveluri și tipuri de testare, tehnici, raportul manual–automat, unelte;
  • medii și date de test: unde se testează, cum se obțin datele, ce integrări sunt reale și ce e simulat;
  • roluri și responsabilități;
  • calendar și estimări;
  • criterii de intrare, de ieșire, de suspendare și reluare;
  • riscuri: atât de produs (ce se poate strica), cât și de proiect (mediu indisponibil, oameni puțini), cu măsuri;
  • livrabile: cazuri de test, rapoarte, metrici.

În Agile, un document de zeci de pagini care se învechește în două săptămâni nu ajută pe nimeni. Adaptările tipice:

  • o strategie de test la nivel de produs, de 2–3 pagini, care se schimbă rar;
  • planificarea pe sprint se face în sprint planning: criteriile de acceptare, ce se automatizează, ce teste nefuncționale sunt necesare;
  • Definition of Done preia rolul criteriilor de ieșire;
  • documentul stă într-un wiki (de exemplu Confluence) și se actualizează când se schimbă ceva.

Ideea de transmis la interviu: valoarea test planului e gândirea și acordul echipei, nu documentul în sine.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi structura și dacă o poți adapta realist. Greșeala tipică este fie necunoașterea secțiunilor, fie insistența pe documente mari în Agile.

32 Mid

Ce este o matrice de trasabilitate și la ce te ajută?

Răspuns scurt: Matricea de trasabilitate leagă cerințele de cazurile de test și, mai departe, de rezultatele lor și de defecte. Te ajută să vezi ce cerințe nu au teste, ce teste trebuie actualizate la o schimbare și care e starea fiecărei cerințe.

O matrice de trasabilitate (Requirements Traceability Matrix, RTM) este un tabel sau o structură de legături între cerințe și artefactele de test. O formă simplă:

Cerință   Descriere                      Cazuri de test         Status    Defecte
US-101    Login cu email                 TC-01, TC-02, TC-03    Trecut    -
US-102    Resetare parolă                TC-04, TC-05           Picat     BUG-231
US-103    Autentificare cu Google        -                      Netestat  -

La ce folosește:

  • acoperire: vezi imediat că US-103 nu are niciun test;
  • analiză de impact: când se schimbă US-102, știi exact ce cazuri de test trebuie revizuite și ce regresie rulezi;
  • raportare: poți spune starea pe cerințe, nu doar pe teste („două din trei funcții sunt gata”), ceea ce înțelege mai ușor un product owner;
  • conformitate: în domenii reglementate (medical, auto, financiar) e adesea obligatoriu să demonstrezi că fiecare cerință a fost testată;
  • trasabilitatea în ambele sensuri te ajută și să găsești teste care nu mai corespund niciunei cerințe, deci pot fi șterse.

În practică, rar se ține un Excel manual. Uneltele de test management (de exemplu Xray sau Zephyr pentru Jira, TestRail) creează legăturile direct între user story, test și bug. Pentru testele automate, poți adăuga în numele testului sau în tag-uri ID-ul cerinței, ca să păstrezi legătura și acolo.

Ce urmărește intervievatorul: Se verifică dacă știi cum demonstrezi acoperirea cerințelor. Greșeala tipică este s-o vezi doar ca pe un document birocratic, fără utilitate în analiza de impact.

33 Senior

Ce metrici de testare urmărești și cum eviți folosirea lor greșită?

Răspuns scurt: Urmăresc metrici de progres (teste rulate, trecute, blocate), de produs (defecte deschise pe severitate, defecte scăpate în producție) și de proces (timp de rulare și stabilitate a suitei). Le folosesc pentru decizii și tendințe, nu pentru a evalua oameni.

Metricile utile se împart de obicei în trei grupe:

Progres

  • teste planificate, rulate, trecute, picate, blocate;
  • acoperirea cerințelor sau a riscurilor.

Calitatea produsului

  • defecte deschise pe severitate și pe modul;
  • defect leakage sau defecte scăpate: câte probleme au fost găsite în producție față de cele găsite înainte de release; e una dintre cele mai sincere metrici despre eficiența testării;
  • densitatea defectelor pe modul, utilă pentru a identifica zonele cu risc mare;
  • timpul de reparare a defectelor critice.

Procesul și automatizarea

  • durata suitei automate și durata pipeline-ului;
  • rata de teste instabile (flaky);
  • timpul de la commit la feedback.

Folosirea greșită apare des:

  • numărul de bug-uri raportate per tester încurajează raportări mărunte și duplicate și strică relația cu developerii;
  • numărul de cazuri de test sau procentul de acoperire luat ca țintă duce la teste multe și slabe; legea lui Goodhart spune că o măsură care devine țintă încetează să mai fie o măsură bună;
  • o cifră fără context („avem 40 de bug-uri deschise”) nu spune nimic fără severitate și tendință.

Abordarea mea: aleg puține metrici legate de o întrebare concretă („găsim defectele înainte de clienți?”), le urmăresc ca tendință și le discut cu echipa. Metricile sunt pentru îmbunătățirea procesului, nu pentru clasamente.

Ce urmărește intervievatorul: La nivel senior se verifică judecata, nu doar lista de metrici. Greșeala tipică este propunerea de metrici care măsoară productivitatea individuală.

34 Senior

Când te oprești din testat? Cum contribui la decizia de go/no-go pentru un release?

Răspuns scurt: Te oprești când sunt îndeplinite criteriile de ieșire convenite sau când riscul rămas e acceptat de echipă. În go/no-go aduc o imagine clară: ce s-a testat, ce defecte sunt deschise, ce riscuri rămân, cu o recomandare argumentată.

Testarea exhaustivă e imposibilă, deci „am terminat de testat” înseamnă de fapt „informația pe care o avem e suficientă ca să decidem”. Răspunsul are două părți.

Când te oprești se stabilește dinainte, prin criterii de ieșire. Exemple:

  • toate testele planificate pe fluxurile critice au fost rulate și trec;
  • nu există defecte de severitate critică sau mare deschise, iar cele medii au o decizie (reparate sau amânate explicit);
  • suita de regresie automată trece pe build-ul candidat;
  • testele nefuncționale cerute (de exemplu de performanță) au rezultate în limitele convenite.

Uneori te oprești și din motive de proiect: termenul sau bugetul. Asta e legitim, dar riscul rămas trebuie spus explicit.

În ședința de go/no-go aduc:

  • un rezumat scurt: ce am acoperit și ce nu, pe zone de risc;
  • defectele deschise, cu impactul pe limbaj de business, nu ID-uri („utilizatorii cu adrese din afara țării nu pot finaliza comanda”);
  • riscurile rămase și măsurile de atenuare: feature flag, lansare graduală, monitorizare, plan de rollback;
  • o recomandare clară, cu argumente.

Un aspect important: QA nu este „poarta” care aprobă sau blochează singură. Decizia aparține product ownerului și echipei, pe baza informațiilor. Rolul meu e ca informația să fie corectă, completă și înțeleasă. Când recomand „no-go”, propun și ce ar trebui să se întâmple ca să devină „go”.

Ce urmărește intervievatorul: Se verifică dacă știi să comunici riscul și să sprijini o decizie de business. Greșeala tipică este „mă opresc când nu mai găsesc bug-uri” sau prezentarea QA ca unic decident.

Agile, Scrum și procesul de lucru

35 Junior

Ce este Scrum? Care sunt rolurile, evenimentele și artefactele?

Răspuns scurt: Scrum este un cadru Agile în care o echipă livrează valoare în iterații scurte numite sprinturi. Are trei roluri (Product Owner, Scrum Master, Developers), cinci evenimente și trei artefacte (Product Backlog, Sprint Backlog, Increment).

Scrum e descris în Scrum Guide (ultima versiune, 2020). Elementele de bază:

Rolurile (în ghid se numesc responsabilități):

  • Product Owner: maximizează valoarea produsului, gestionează și ordonează Product Backlogul.
  • Scrum Master: ajută echipa să aplice Scrum, elimină obstacolele, facilitează evenimentele.
  • Developers: toți cei care construiesc incrementul. Testerii fac parte din această categorie; ghidul nu definește un rol separat de QA.

Evenimentele:

  • Sprint: iterația, de maximum o lună, adesea două săptămâni; conține toate celelalte evenimente;
  • Sprint Planning: ce se livrează în sprint și cum;
  • Daily Scrum: 15 minute zilnic pentru sincronizare și ajustarea planului;
  • Sprint Review: se prezintă incrementul și se discută cu stakeholderii;
  • Sprint Retrospective: echipa discută cum își îmbunătățește modul de lucru.

Rafinarea backlogului (refinement) e o activitate continuă, nu un eveniment oficial, dar QA are mult de câștigat participând la ea.

Artefactele, fiecare cu un angajament:

  • Product Backlog, cu Product Goal;
  • Sprint Backlog, cu Sprint Goal;
  • Increment, cu Definition of Done.

Pentru un QA e important să subliniezi că, în Scrum, calitatea e responsabilitatea întregii echipe. Incrementul trebuie să fie utilizabil și să respecte Definition of Done la final de sprint, deci testarea se face în sprint, nu după.

Ce urmărește intervievatorul: Se verifică cunoașterea de bază a cadrului de lucru din majoritatea echipelor. Greșeala tipică este inventarea unui „rol de tester” în Scrum sau confundarea review-ului cu retrospectiva.

36 Junior

Care este rolul unui QA într-un sprint Scrum, de la planificare până la review?

Răspuns scurt: QA participă la rafinare și planificare ca să clarifice criteriile de acceptare și estimările de testare, testează continuu pe parcursul sprintului, automatizează și participă la review și retrospectivă cu observații despre calitate.

Un QA bun lucrează pe tot parcursul sprintului, nu doar la final.

Rafinare și planificare

  • pune întrebări despre user stories: cazuri limită, erori, cerințe nefuncționale, impact asupra altor funcții;
  • ajută la scrierea criteriilor de acceptare clare și testabile;
  • include efortul de testare și automatizare în estimare, ca să nu se ajungă la „gata dezvoltarea, testăm sprintul viitor”.

În timpul sprintului

  • pregătește scenariile și datele de test cât timp developerii implementează;
  • testează fiecare story imediat ce e gata, eventual chiar pe branch-ul developerului, ca feedbackul să vină rapid;
  • automatizează testele pentru funcționalitatea nouă și adaugă-le în regresie;
  • semnalează la Daily Scrum blocajele: mediu căzut, story-uri care ajung toate în ultima zi.

Review și retrospectivă

  • poate demonstra funcționalitatea și răspunde despre ce a fost testat;
  • aduce în retrospectivă observații concrete: „trei bug-uri au venit din criterii de acceptare neclare; propun sesiuni three amigos”.

Problema clasică pe care un QA o semnalează este „mini-waterfall-ul” în sprint: toate story-urile sunt livrate spre testare în ultimele două zile. Soluțiile includ story-uri mai mici, limitarea muncii în curs și ajutorul developerilor la testare. Arată la interviu că știi să ridici această problemă constructiv.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că te implici devreme, nu doar la sfârșit. Greșeala tipică este descrierea QA ca etapă separată după dezvoltare.

37 Junior

Care este diferența dintre criteriile de acceptare și Definition of Done?

Răspuns scurt: Criteriile de acceptare sunt specifice fiecărui user story și descriu ce trebuie să facă funcția ca să fie acceptată. Definition of Done se aplică tuturor elementelor și descrie standardul de calitate comun: cod revizuit, teste trecute, documentație actualizată.

Ambele răspund la „când e gata?”, dar la niveluri diferite.

Criteriile de acceptare (acceptance criteria):

  • sunt unice pentru fiecare user story;
  • descriu comportamentul funcțional așteptat, din perspectiva utilizatorului;
  • sunt stabilite împreună cu product ownerul, ideal înainte de sprint planning.

Exemplu pentru „Ca utilizator vreau să-mi pot salva adresa de livrare”:

  • adresa salvată apare preselectată la următoarea comandă;
  • pot salva maximum 5 adrese;
  • câmpul cod poștal acceptă doar 6 cifre.

Definition of Done (DoD):

  • e comună pentru toate elementele din backlog, stabilită de echipă (sau la nivel de organizație);
  • descrie standardul de calitate al incrementului.

Exemplu:

  • codul a trecut de code review;
  • testele unitare și de integrare trec în CI;
  • criteriile de acceptare au fost verificate de QA;
  • testele automate pentru funcția nouă au fost adăugate;
  • nu există bug-uri critice deschise legate de story;
  • documentația relevantă e actualizată.

Un story e gata doar când îndeplinește și criteriile proprii de acceptare, și Definition of Done. Ca QA, DoD-ul e unul dintre locurile unde poți influența calitatea întregii echipe: de exemplu, propunând să includă verificarea de accesibilitate sau testele automate. Nu confunda nici cu Definition of Ready, care spune când un story e suficient de clar ca să intre în sprint.

Ce urmărește intervievatorul: Se verifică dacă distingi standardul comun de cerințele specifice. Greșeala tipică este să le consideri sinonime.

38 Junior

Cum scrii criterii de acceptare în format Given/When/Then? Dă un exemplu.

Răspuns scurt: Formatul Gherkin descrie un scenariu prin context (Given), acțiune (When) și rezultat observabil (Then). Fiecare scenariu acoperă un singur comportament și poate deveni direct un test automat.

Gherkin este limbajul folosit în BDD (Behavior Driven Development) de unelte precum Cucumber. Structura:

  • Given: contextul inițial, starea sistemului;
  • When: acțiunea utilizatorului sau evenimentul;
  • Then: rezultatul observabil;
  • And / But: continuă pasul anterior.

Exemplu pentru un cod de reducere:

Feature: Coduri de reducere în coș

  Scenario: Cod valid aplicat pe un coș eligibil
    Given am în coș produse în valoare de 250 lei
    And codul "TOAMNA20" oferă 20% reducere la comenzi de minimum 200 lei
    When aplic codul "TOAMNA20"
    Then totalul coșului devine 200 lei
    And văd mesajul "Codul a fost aplicat"

  Scenario: Cod valid aplicat sub pragul minim
    Given am în coș produse în valoare de 150 lei
    When aplic codul "TOAMNA20"
    Then totalul coșului rămâne 150 lei
    And văd mesajul "Comanda minimă pentru acest cod este 200 lei"

Reguli bune:

  • un scenariu, un comportament;
  • limbaj de business, nu de interfață: „aplic codul”, nu „dau click pe butonul cu id-ul apply-btn”;
  • rezultatul din Then trebuie să fie verificabil;
  • pentru mai multe seturi de date, folosește Scenario Outline cu un tabel Examples, ca să nu repeți scenariul.

Avantajul principal: product ownerul, developerul și QA citesc același document, iar ambiguitățile ies la iveală înainte de implementare. Faptul că scenariile pot fi automatizate e un bonus, nu scopul principal.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să transformi o cerință în comportament testabil. Greșeala tipică este scrierea scenariilor cu detalii de interfață sau mai multe comportamente într-unul.

39 Mid

Ce este o sesiune „three amigos” și ce legătură are cu BDD?

Răspuns scurt: Three amigos este o discuție scurtă înainte de implementarea unui story între perspectiva de business (product owner), cea de dezvoltare și cea de testare, în care se clarifică exemple concrete. Este practica centrală din BDD.

Three amigos reunește trei perspective asupra aceluiași user story:

  • business (product owner sau analist): ce problemă rezolvăm și de ce;
  • dezvoltare: cum se poate implementa, ce constrângeri tehnice există;
  • testare: ce poate merge prost, care sunt cazurile limită și cum verificăm.

Nu e obligatoriu să fie exact trei oameni; contează perspectivele. Sesiunea durează de obicei 20–30 de minute per story și are loc înainte ca story-ul să intre în sprint sau la începutul lui.

Un format util este Example Mapping:

  • un card galben pentru story;
  • carduri albastre pentru reguli;
  • carduri verzi pentru exemple concrete ale fiecărei reguli;
  • carduri roșii pentru întrebările la care nimeni nu știe răspunsul.

Dacă la final ai multe carduri roșii, story-ul nu e gata de implementare. Dacă ai foarte multe reguli, story-ul e prea mare și trebuie împărțit.

Legătura cu BDD: Behavior Driven Development înseamnă în primul rând colaborare pe baza exemplelor. Exemplele din three amigos devin scenarii Given/When/Then, care pot fi automatizate apoi cu Cucumber sau cu teste Playwright obișnuite.

O greșeală frecventă în echipe este adoptarea uneltei (Cucumber) fără conversație. Rezultatul este un strat suplimentar de cod de întreținut, fără beneficiul principal. La interviu, subliniază că valoarea BDD e discuția, iar automatizarea e opțională.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că BDD înseamnă colaborare, nu doar o unealtă. Greșeala tipică este reducerea BDD la „scriem teste în Cucumber”.

40 Mid

Cum testezi o funcționalitate atunci când cerințele sunt incomplete sau lipsesc?

Răspuns scurt: Clarific cât pot cu product ownerul și developerii, folosesc surse alternative (versiunea anterioară, aplicații similare, standarde, designul), îmi documentez presupunerile, apoi completez cu testare exploratorie și scriu ce am aflat ca să devină cerință.

E o situație des întâlnită, mai ales în start-up-uri sau proiecte vechi. Abordarea mea:

1. Pun întrebări devreme. Cer o discuție scurtă cu product ownerul și cu developerul. Vin cu întrebări concrete, nu cu „cerința e incompletă”: ce se întâmplă dacă lista e goală, cine are acces, care e limita maximă.

2. Folosesc surse alternative de informații (ISTQB le numește „test oracle”, adică sursa din care afli rezultatul așteptat):

  • designul din Figma și prototipurile;
  • comportamentul versiunii anterioare sau al unei funcții similare din aplicație;
  • aplicații concurente și convenții general acceptate;
  • standarde și legislație (de exemplu GDPR, WCAG);
  • codul și testele unitare existente, discutate cu developerul;
  • tichetele de suport și feedbackul utilizatorilor.

3. Îmi documentez presupunerile și le trimit echipei: „Am presupus că emailul e unic per cont; confirmați?”. Așa, o neînțelegere iese la iveală devreme.

4. Folosesc testare exploratorie cu charter-uri, pentru că ea funcționează bine când nu ai un script clar.

5. Raportez cu atenție. Când comportamentul pare greșit, dar nu e acoperit de cerință, îl semnalez ca întrebare sau observație, nu neapărat ca bug.

6. Las în urmă cerința. Ce am clarificat se adaugă în story sau în documentație, ca următorul om să nu o ia de la zero.

Pe termen lung, propun ca echipa să adopte Definition of Ready, ca story-urile neclare să nu mai intre în sprint.

Ce urmărește intervievatorul: Intervievatorul verifică autonomia și comunicarea în situații ambigue. Greșeala tipică este să spui că aștepți cerințe complete înainte să începi.

41 Mid

Prin ce diferă testarea în Waterfall, V-model și Agile?

Răspuns scurt: În Waterfall testarea e o fază separată, după dezvoltare. V-model asociază fiecărei etape de dezvoltare un nivel de testare și planifică testarea devreme. În Agile testarea e continuă, în fiecare iterație, iar calitatea e responsabilitatea întregii echipe.

Waterfall e un model secvențial: cerințe, design, implementare, testare, livrare. Testarea începe după ce codul e gata.

  • avantaj: documentație bogată, planificare clară, potrivit pentru proiecte cu cerințe stabile;
  • dezavantaj: defectele din cerințe se descoperă târziu, când sunt scumpe; faza de testare e prima comprimată când proiectul întârzie.

V-model e o variantă de Waterfall în care fiecare etapă de dezvoltare are un nivel de testare corespondent:

  • cerințele de business corespund testării de acceptanță;
  • specificația de sistem, testării de sistem;
  • designul arhitectural, testării de integrare;
  • designul detaliat, testării de componentă.

Testele se proiectează în paralel cu etapa corespondentă, deci testarea statică și planificarea încep devreme. Execuția rămâne totuși la final. E folosit în domenii reglementate, de exemplu în industria auto sau medicală.

Agile (Scrum, Kanban) lucrează iterativ, în bucăți mici:

  • testarea se face în fiecare sprint, pe măsură ce story-urile sunt gata;
  • automatizarea e esențială, pentru că regresia se repetă des;
  • documentația e mai ușoară, iar comunicarea directă contează mai mult;
  • QA face parte din echipă, nu dintr-un departament separat.

La interviu, merită să spui că multe organizații lucrează hibrid: de exemplu, sprinturi în dezvoltare, dar o fază de UAT la client înainte de release. Un QA bun se adaptează la model și înțelege ce riscuri vin cu fiecare.

Ce urmărește intervievatorul: Se verifică dacă înțelegi cum schimbă modelul de lucru momentul și rolul testării. Greșeala tipică este prezentarea Waterfall ca fiind „greșit” fără nuanțe.

42 Senior

Echipa livrează la două săptămâni, iar regresia manuală durează patru zile. Cum reorganizezi testarea?

Răspuns scurt: Aș reduce regresia manuală prin automatizarea fluxurilor critice stabile, prioritizarea pe risc a restului, testarea continuă în sprint și mutarea verificărilor mai jos în piramidă, cu obiectivul ca regresia să ruleze automat în CI, nu ca fază separată.

Patru zile de regresie manuală într-un sprint de zece zile înseamnă că testarea devine blocajul. Planul meu, în etape:

1. Analizez suita existentă.

  • care teste au găsit bug-uri în ultimele luni și care nu;
  • care sunt duplicate, învechite sau verifică funcții rar folosite;
  • care acoperă fluxuri critice pentru business. De obicei, o parte semnificativă din suită se poate elimina sau comasa.

2. Prioritizez pe risc. Împart testele în niveluri: critic (rulat la fiecare release), important (rulat când zona e atinsă de schimbări), restul (rulat periodic sau doar exploratoriu).

3. Automatizez strategic.

  • încep cu smoke-ul și fluxurile critice stabile;
  • verificările de logică se mută pe API sau la nivel unitar, care sunt mai rapide și mai stabile decât UI-ul;
  • testele rulează în CI la fiecare merge, nu doar la final de sprint.

4. Schimb procesul.

  • fiecare story nou vine cu testele automate în Definition of Done, ca datoria să nu crească;
  • regresie selectivă pe baza analizei de impact;
  • testare exploratorie țintită pe zonele schimbate în locul parcurgerii mecanice a scripturilor.

5. Măsor și comunic. Urmăresc durata regresiei și defectele scăpate în producție, ca să arăt că reducerea nu crește riscul.

Toată echipa trebuie implicată: developerii pot ajuta la automatizare și la testele unitare. Țintesc reducerea treptată pe parcursul mai multor sprinturi, nu o rescriere completă dintr-odată.

Ce urmărește intervievatorul: La nivel senior se verifică dacă știi să transformi un proces, nu doar să automatizezi. Greșeala tipică este „automatizăm toată regresia”, fără analiză și prioritizare.

Testare API și HTTP

43 Junior

Ce este un API REST și ce verifici atunci când testezi un endpoint?

Răspuns scurt: Un API REST expune resurse prin URL-uri și metode HTTP, de obicei cu date JSON. La un endpoint verific codul de stare, structura și conținutul răspunsului, validările de intrare, autentificarea și autorizarea, headerele și timpul de răspuns.

Un API (Application Programming Interface) este interfața prin care două programe comunică. Un API REST folosește HTTP: fiecare resursă are un URL (de exemplu /api/users/42), iar acțiunile se exprimă prin metode HTTP (GET, POST, PUT, PATCH, DELETE). Un endpoint este combinația dintre metodă și URL. Datele circulă de obicei în format JSON, iar serverul nu păstrează starea sesiunii între request-uri (stateless).

La testarea unui endpoint, de exemplu POST /api/orders, verific:

  • codul de stare: 201 la creare reușită, 400 la date invalide, 401 fără autentificare;
  • corpul răspunsului: structura (câmpurile există, au tipul corect) și valorile (totalul e calculat corect);
  • efectul real: comanda chiar există, verificat cu un GET sau în baza de date;
  • validările: câmpuri obligatorii lipsă, tipuri greșite, valori la limite, câmpuri în plus;
  • autentificarea și autorizarea: fără token, cu token expirat, cu token al altui utilizator (pot accesa comenzile altcuiva?);
  • headerele: Content-Type, headerele de cache sau de securitate;
  • timpul de răspuns și comportamentul la volume mari de date;
  • mesajele de eroare: clare pentru client, fără detalii interne precum stack trace-uri.

Testarea API e valoroasă pentru că e rapidă, stabilă și prinde bug-uri de logică înainte să existe interfața. Multe defecte de securitate, mai ales cele de autorizare, se văd mult mai ușor la nivel de API decât din UI.

Ce urmărește intervievatorul: Se verifică dacă știi ce înseamnă REST și dacă testarea ta merge dincolo de „primesc 200”. Greșeala tipică este ignorarea autorizării și a efectului real al request-ului.

44 Junior

Ce metode HTTP cunoști și ce înseamnă că o metodă este idempotentă?

Răspuns scurt: GET citește, POST creează, PUT înlocuiește, PATCH modifică parțial, DELETE șterge. O metodă e idempotentă dacă repetarea aceluiași request are același efect asupra serverului ca o singură execuție: GET, PUT și DELETE sunt idempotente, POST nu.

Metodele principale:

  • GET: citește o resursă; nu ar trebui să modifice nimic pe server.
  • POST: creează o resursă nouă sau declanșează o acțiune.
  • PUT: înlocuiește complet o resursă; câmpurile netrimise pot fi șterse sau resetate.
  • PATCH: modifică doar câmpurile trimise.
  • DELETE: șterge o resursă.
  • HEAD și OPTIONS: mai rar testate; OPTIONS apare la preflight-ul CORS din browser.

Metodă sigură (safe) înseamnă că nu modifică starea serverului: GET, HEAD, OPTIONS.

Idempotentă înseamnă că, dacă trimiți același request de mai multe ori, starea finală a serverului e aceeași ca după o singură trimitere. Conform specificației HTTP (RFC 9110), GET, HEAD, OPTIONS, PUT și DELETE sunt idempotente. POST nu este, iar PATCH nu este garantat idempotent.

Exemple:

  • PUT /users/42 cu același corp, trimis de trei ori: utilizatorul are aceleași date;
  • DELETE /users/42 de trei ori: utilizatorul e șters. Codul de răspuns poate diferi (200 sau 204 prima dată, apoi 404), dar starea serverului e aceeași;
  • POST /orders de trei ori: trei comenzi.

De ce contează pentru un tester: rețelele pierd răspunsuri, iar clienții reîncearcă request-uri. Dacă un POST de plată se repetă, poți avea plăți duble. Un test bun verifică ce se întâmplă la trimiterea dublă și dacă API-ul suportă un mecanism de protecție, cum ar fi o cheie de idempotență trimisă în header.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea semanticii HTTP, nu doar a numelor. Greșeala tipică este confuzia dintre PUT și PATCH sau afirmația că DELETE nu e idempotent pentru că a doua oară întoarce 404.

45 Junior

Explică clasele de coduri de stare HTTP. Care e diferența dintre 401 și 403?

Răspuns scurt: 2xx înseamnă succes, 3xx redirecționare, 4xx eroare a clientului, 5xx eroare a serverului. 401 înseamnă că nu ești autentificat sau autentificarea e invalidă, iar 403 că ești autentificat, dar nu ai drept de acces la resursă.

Codurile de stare spun clientului rezultatul request-ului. Clasele:

  • 1xx informațional, rar întâlnit în testarea de zi cu zi.
  • 2xx succes:
  • 200 OK: request reușit, cu corp în răspuns;
  • 201 Created: resursă creată, de obicei după POST;
  • 204 No Content: reușit, fără corp, des după DELETE.
  • 3xx redirecționare: 301 permanent, 302 temporar, 304 Not Modified pentru cache.
  • 4xx eroarea clientului:
  • 400 Bad Request: date invalide sau JSON malformat;
  • 401 Unauthorized: lipsește autentificarea sau tokenul e invalid ori expirat;
  • 403 Forbidden: ești autentificat, dar nu ai permisiunea;
  • 404 Not Found: resursa nu există;
  • 409 Conflict: conflict de stare, de exemplu email deja folosit;
  • 422 Unprocessable Content: format corect, dar validare de business eșuată (folosit de unele API-uri);
  • 429 Too Many Requests: limită de request-uri depășită.
  • 5xx eroarea serverului: 500 eroare internă, 502 și 503 probleme de gateway sau serviciu indisponibil, 504 timeout.

401 vs 403: un utilizator fără token care cere /api/admin/users primește 401. Un utilizator logat, dar fără rol de admin, primește 403. Numele „Unauthorized” e istoric derutant: înseamnă de fapt „neautentificat”.

Ca tester, verifici că API-ul folosește codurile corect. Un 500 la date invalide e un bug: serverul ar trebui să valideze și să răspundă cu 400. De asemenea, uneori 404 e folosit intenționat în loc de 403, ca să nu dezvălui existența resursei.

Ce urmărește intervievatorul: Se verifică cunoașterea practică a codurilor și capacitatea de a recunoaște folosirea lor greșită. Greșeala tipică este inversarea lui 401 cu 403.

46 Junior

Cum organizezi testarea unui API în Postman? Ce sunt colecțiile, mediile și variabilele?

Răspuns scurt: O colecție grupează request-urile unui API, un mediu (environment) conține setul de variabile pentru un anumit server (de exemplu test sau staging), iar variabilele permit refolosirea valorilor precum URL-ul de bază sau tokenul, fără să le scrii în fiecare request.

Postman este una dintre cele mai folosite unelte pentru testarea manuală și semi-automată a API-urilor. Conceptele de bază:

  • Collection: un set de request-uri organizate în foldere, de exemplu „Utilizatori”, „Comenzi”, „Plăți”. Colecția se poate exporta în JSON, versiona în Git și rula automat.
  • Environment: un set de variabile pentru un anumit mediu. Ai, de exemplu, mediul „Test” cu baseUrl = https://test.exemplu.ro și mediul „Staging” cu alt URL. Schimbi mediul dintr-un meniu și aceleași request-uri merg pe alt server.
  • Variables: se folosesc cu acolade duble, de exemplu {{baseUrl}}/api/users. Există mai multe niveluri (scope): global, collection, environment, data, local. Variabila cu scope-ul cel mai specific are prioritate.

O structură bună:

  • baseUrl, credențialele și tokenul ca variabile de mediu;
  • autentificarea configurată o singură dată la nivel de colecție, moștenită de toate request-urile;
  • pre-request scripts pentru date generate (de exemplu un email unic);
  • tests (în versiunile recente, tab-ul „Scripts”, secțiunea „Post-response”) pentru verificări automate după fiecare request.

Pentru securitate: valorile sensibile se marchează ca secret și nu se exportă sau partajează în colecții publice.

Colecția se poate rula integral din Collection Runner, cu date dintr-un fișier CSV sau JSON (data-driven), sau din linie de comandă cu Newman, ceea ce o face potrivită pentru CI.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești Postman organizat, nu doar trimiți request-uri izolate. Greșeala tipică este scrierea URL-urilor și tokenurilor direct în fiecare request.

47 Junior

Scrie în Postman un test care verifică statusul răspunsului, un câmp din JSON și timpul de răspuns.

Răspuns scurt: Folosești pm.test cu aserțiuni pm.expect sau pm.response.to: verifici pm.response.code, parsezi corpul cu pm.response.json() și compari valorile, iar pm.response.responseTime îți dă durata în milisecunde.

Testele din Postman se scriu în JavaScript, în secțiunea de scripturi care rulează după răspuns. API-ul pm oferă acces la request, răspuns și variabile, iar aserțiunile folosesc sintaxa Chai.

Exemplu pentru GET {{baseUrl}}/api/users/42:

JavaScript
pm.test("Statusul este 200", function () {
  pm.response.to.have.status(200);
});

const body = pm.response.json();

pm.test("Utilizatorul are id-ul și emailul corecte", function () {
  pm.expect(body.id).to.eql(42);
  pm.expect(body.email).to.be.a("string").and.include("@");
});

pm.test("Lista de roluri nu e goală", function () {
  pm.expect(body.roles).to.be.an("array").that.is.not.empty;
});

pm.test("Răspuns sub 800 ms", function () {
  pm.expect(pm.response.responseTime).to.be.below(800);
});

pm.test("Content-Type este JSON", function () {
  pm.expect(pm.response.headers.get("Content-Type")).to.include("application/json");
});

Câteva observații:

  • fiecare pm.test apare separat în rezultate, deci scrii verificări mici și cu nume clare;
  • to.eql compară valori (inclusiv obiecte, în profunzime), nu referințe;
  • pragul de timp e orientativ: pe un mediu de test lent poate da fals pozitive, așa că îl alegi realist sau îl lași doar pentru verificări de performanță dedicate;
  • poți salva o valoare pentru request-urile următoare, de exemplu pm.environment.set("userId", body.id).

Postman are și fragmente predefinite (snippets) pentru testele uzuale, dar la interviu e bine să știi să le scrii singur.

Ce urmărește intervievatorul: Se verifică dacă poți scrie aserțiuni reale, nu doar trimite request-uri. Greșeala tipică este verificarea doar a statusului 200.

48 Junior

Care este diferența dintre path parameters, query parameters, headers și body?

Răspuns scurt: Path parameters identifică resursa în URL (/users/42), query parameters filtrează sau sortează (?page=2), headers transportă metadate precum autentificarea și tipul conținutului, iar body conține datele trimise, de obicei la POST, PUT și PATCH.

Un request HTTP poate transmite informații în patru locuri:

  • Path parameters: fac parte din URL și identifică o resursă anume. GET /api/users/42/orders/7 cere comanda 7 a utilizatorului 42.
  • Query parameters: după semnul ?, perechi cheie–valoare separate prin &. Se folosesc pentru filtrare, sortare, paginare, căutare. GET /api/products?category=laptop&sort=price&page=2
  • Headers: metadate despre request.
  • Authorization: Bearer <token> pentru autentificare;
  • Content-Type: application/json spune ce format are corpul trimis;
  • Accept spune ce format vrei înapoi.
  • Body: datele propriu-zise, de obicei JSON, la POST, PUT, PATCH.
POST /api/users/42/addresses HTTP/1.1
Host: test.exemplu.ro
Authorization: Bearer eyJhbGciOi...
Content-Type: application/json

{"city": "Cluj-Napoca", "street": "Str. Memorandumului 1", "zip": "400114"}

Ce testezi pentru fiecare:

  • path: ID inexistent, ID al altui utilizator, format greșit (/users/abc);
  • query: parametri lipsă, valori invalide (page=-1), parametri necunoscuți, caractere speciale care trebuie codificate în URL;
  • headers: lipsa tokenului, Content-Type greșit;
  • body: câmpuri lipsă, tipuri greșite, JSON malformat, câmpuri în plus.

O regulă de securitate bună de menționat: datele sensibile (parole, tokenuri, date personale) nu se pun în query parameters, pentru că URL-urile ajung în loguri, istoricul browserului și analytics.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi anatomia unui request. Greșeala tipică este confuzia dintre path și query sau trimiterea datelor sensibile în URL.

49 Mid

Ce teste negative faci pe un API și cum validezi structura răspunsului?

Răspuns scurt: Trimit date lipsă, de tip greșit, la limite sau peste ele, JSON malformat, tokenuri lipsă sau ale altui utilizator și verific coduri de eroare corecte și mesaje clare. Structura o validez cu o schemă JSON, nu câmp cu câmp.

Testele negative verifică faptul că API-ul refuză corect ce trebuie refuzat. Pe un POST /api/users:

Date de intrare

  • câmpuri obligatorii lipsă, pe rând;
  • tipuri greșite: "age": "douăzeci", "age": null;
  • valori la limite și peste: șir gol, text foarte lung, număr negativ;
  • format invalid: email fără @, dată imposibilă (31 februarie);
  • câmpuri în plus, mai ales sensibile, de exemplu "role": "admin"; API-ul nu ar trebui să permită ridicarea privilegiilor așa (mass assignment);
  • JSON malformat și Content-Type greșit;
  • duplicate: același email a doua oară (de așteptat 409 sau 400).

Securitate

  • fără token, token expirat, token modificat;
  • acces la resursele altui utilizator prin schimbarea ID-ului în URL; această clasă de vulnerabilități se numește BOLA sau IDOR și e prima în OWASP API Security Top 10;
  • caractere speciale și încercări simple de injecție.

Pentru fiecare verifici: cod 4xx corect (nu 500), mesaj de eroare clar, fără stack trace, și că nimic nu s-a salvat.

Validarea structurii cu JSON Schema e mai robustă decât verificarea manuală a fiecărui câmp:

JavaScript
const schema = {
  type: "object",
  required: ["id", "email", "createdAt"],
  properties: {
    id: { type: "integer" },
    email: { type: "string" },
    createdAt: { type: "string" }
  }
};
pm.test("Răspunsul respectă schema", () => {
  pm.response.to.have.jsonSchema(schema);
});

Dacă echipa are specificație OpenAPI, schemele se pot lua direct de acolo, ca testele să rămână sincronizate cu contractul.

Ce urmărește intervievatorul: Se verifică dacă știi să ataci un API și să-i verifici contractul. Greșeala tipică este testarea doar a fluxului pozitiv și acceptarea unui 500 ca răspuns valid la date greșite.

50 Mid

Cum funcționează autentificarea cu token (Bearer, JWT) și ce testezi la ea?

Răspuns scurt: Clientul obține un token după login și îl trimite în headerul Authorization: Bearer la fiecare request. Un JWT conține date semnate (de exemplu utilizatorul și expirarea). Testezi lipsa, expirarea, modificarea tokenului, delogarea și accesul la resursele altora.

Fluxul tipic:

  • clientul trimite credențialele la un endpoint de login (sau trece printr-un flux OAuth 2.0);
  • serverul răspunde cu un access token și adesea cu un refresh token;
  • clientul trimite access tokenul la fiecare request: Authorization: Bearer <token>;
  • când access tokenul expiră, clientul obține unul nou cu refresh tokenul.

Un JWT (JSON Web Token) are trei părți separate prin puncte: header, payload și semnătură, codificate Base64URL. Payloadul conține „claims”, de exemplu sub (utilizatorul), exp (expirarea), roluri. Important: payloadul nu este criptat, doar semnat. Oricine îl poate decoda (de exemplu pe jwt.io), deci nu trebuie să conțină parole sau date sensibile. Semnătura garantează doar că nu a fost modificat.

Ce testezi:

  • request fără token și cu token malformat: 401;
  • token expirat: 401, iar fluxul de refresh funcționează;
  • token cu payload modificat (de exemplu rolul schimbat în admin) dar semnătura veche: trebuie respins;
  • algoritmul none: serverul nu trebuie să accepte tokenuri nesemnate;
  • token al utilizatorului A folosit pentru resursele utilizatorului B: 403 sau 404;
  • după logout sau schimbarea parolei: ce se întâmplă cu tokenurile vechi (comportamentul depinde de implementare, întreabă care e cerința);
  • tokenul nu apare în URL sau în loguri;
  • unde e stocat în browser (cookie HttpOnly vs local storage) și ce implicații de securitate are.

Pentru automatizare, obții tokenul o singură dată într-un pas de setup și îl refolosești, în loc să faci login la fiecare test.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul și riscurile, nu doar unde pui tokenul. Greșeala tipică este credința că JWT-ul e criptat.

51 Mid

Cum înlănțuiești request-uri în Postman și cum rulezi o colecție în CI cu Newman?

Răspuns scurt: Salvezi valori din răspunsul unui request în variabile (pm.environment.set sau pm.collectionVariables.set) și le folosești în request-urile următoare. În CI rulezi colecția exportată cu Newman, din linia de comandă, cu un raport JUnit.

Înlănțuirea (chaining) e necesară când un request depinde de rezultatul altuia: login, apoi creare comandă, apoi citirea ei, apoi anulare.

În scriptul post-response de la login:

JavaScript
const body = pm.response.json();
pm.collectionVariables.set("token", body.accessToken);

În request-ul de creare comandă, headerul devine Authorization: Bearer {{token}}, iar după creare salvezi ID-ul:

JavaScript
pm.collectionVariables.set("orderId", pm.response.json().id);

Următorul request folosește {{baseUrl}}/api/orders/{{orderId}}. Ordinea de execuție în Collection Runner este ordinea din colecție, iar pm.execution.setNextRequest("Nume") permite salturi, de exemplu pentru a repeta un request până se schimbă o stare.

Newman este runnerul de linie de comandă al Postman:

BASH
npm install -g newman newman-reporter-htmlextra
newman run comenzi.postman_collection.json \
  -e test.postman_environment.json \
  --env-var "password=$API_PASSWORD" \
  -r cli,junit,htmlextra \
  --reporter-junit-export results/newman.xml

Observații:

  • secretele vin din variabilele pipeline-ului (de exemplu GitHub Actions secrets), nu din fișierul de mediu salvat în Git;
  • raportul JUnit e citit de majoritatea sistemelor de CI, care afișează testele picate;
  • Newman întoarce cod de ieșire diferit de zero când pică un test, deci pipeline-ul se oprește singur;
  • colecțiile trebuie să fie independente de ordinea rulării anterioare: fiecare rulare își creează datele proprii.

Postman are și un CLI propriu (Postman CLI), dar Newman rămâne foarte folosit, fiind open source.

Ce urmărește intervievatorul: Se verifică dacă știi să transformi o colecție manuală într-o suită automată. Greșeala tipică este depunerea parolelor în fișierele de mediu comise în repository.

52 Mid

Cum testezi un API cu Playwright și când preferi asta în locul Postman?

Răspuns scurt: Folosești fixture-ul request (APIRequestContext) pentru a trimite request-uri și expect pentru aserțiuni, în aceleași teste și același repository ca testele UI. Îl preferi când vrei cod versionat, reutilizare cu testele de UI și setup de date prin API.

Playwright Test oferă fixture-ul request, un client HTTP care moștenește baseURL și headerele din configurație.

TypeScript
import { test, expect } from '@playwright/test';

test('creează un utilizator și îl citește înapoi', async ({ request }) => {
  const email = `qa+${Date.now()}@example.com`;

  const created = await request.post('/api/users', {
    data: { name: 'Ana Test', email },
  });
  expect(created.status()).toBe(201);
  const user = await created.json();
  expect(user).toMatchObject({ name: 'Ana Test', email });

  const fetched = await request.get(`/api/users/${user.id}`);
  expect(fetched).toBeOK();
  expect((await fetched.json()).email).toBe(email);
});

Câteva lucruri utile:

  • data este serializat automat ca JSON; pentru formulare există form, iar pentru fișiere multipart;
  • expect(response).toBeOK() verifică un status între 200 și 299;
  • în playwright.config.ts setezi use: { baseURL, extraHTTPHeaders }, de exemplu cu tokenul citit din variabile de mediu;
  • page.request partajează cookie-urile cu pagina, util când testul combină UI și API.

Când aleg Playwright în loc de Postman:

  • echipa are deja testele UI în Playwright și vrea un singur framework, un singur raport și un singur pipeline;
  • am nevoie de setup prin API pentru testele UI: creez rapid datele prin API, apoi verific în interfață;
  • vreau code review, refactorizare, tipuri TypeScript și reutilizare de funcții.

Postman rămâne excelent pentru explorare manuală, depanare și pentru membrii echipei care nu scriu cod. Cele două se completează.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi testarea API ca parte a frameworkului de automatizare. Greșeala tipică este necunoașterea faptului că Playwright poate testa API-uri.

53 Senior

Într-o arhitectură cu microservicii, cum testezi integrarea dintre servicii? Ce sunt contract testing și mocking-ul?

Răspuns scurt: Combin teste de integrare țintite, servicii simulate (mocks, stubs) pentru dependențele instabile sau externe și contract testing, care verifică automat că un consumator și un furnizor respectă același contract, fără să ruleze întregul sistem.

Cu zeci de servicii, testele end-to-end prin tot sistemul devin lente, fragile și greu de depanat. Strategia uzuală are mai multe straturi.

Mocking și stubbing

  • un stub întoarce răspunsuri predefinite; un mock verifică în plus cum a fost apelat;
  • se folosesc pentru dependențe externe (procesator de plăți, servicii de curierat) sau instabile;
  • unelte: WireMock, Mock Service Worker, iar în Playwright page.route() interceptează request-urile din browser;
  • permit și teste greu de făcut altfel: timeout, răspuns 503, date corupte.

Riscul mock-urilor: dacă serviciul real se schimbă, mock-ul rămâne vechi, iar testele trec în continuare deși integrarea e stricată.

Contract testing rezolvă exact acest risc. În varianta consumer-driven, cu unealta Pact:

  • consumatorul (de exemplu serviciul de comenzi) scrie teste care descriu ce request-uri trimite și ce răspuns așteaptă; rezultatul este un fișier de contract;
  • contractul e publicat într-un broker;
  • furnizorul (serviciul de utilizatori) rulează contractul ca test în pipeline-ul propriu, pe codul real;
  • dacă furnizorul schimbă un câmp folosit de consumator, pipeline-ul lui pică înainte de deploy.

Avantajul: feedback rapid, independent pentru fiecare echipă, fără mediu complet de integrare.

Strategia completă pe care aș propune-o: teste unitare și de componentă în fiecare serviciu, contract testing între servicii, câteva teste end-to-end doar pentru fluxurile critice de business, plus monitorizare în producție. Așa mutăm cea mai mare parte a verificărilor acolo unde sunt rapide și ușor de depanat.

Ce urmărește intervievatorul: La nivel senior se verifică dacă știi să testezi sisteme distribuite fără să depinzi de teste end-to-end. Greșeala tipică este propunerea de teste end-to-end pentru toate integrările.

SQL și baze de date pentru QA

54 Junior

De ce are nevoie un QA Engineer de SQL? Dă exemple concrete de folosire.

Răspuns scurt: SQL îți permite să verifici direct în baza de date efectul acțiunilor din aplicație, să pregătești și să cureți date de test, să găsești date pentru scenarii specifice și să investighezi cauza unui bug.

Interfața și API-ul îți arată ce vrea aplicația să-ți arate. Baza de date îți arată ce s-a întâmplat de fapt. SQL (Structured Query Language) e limbajul prin care interoghezi bazele de date relaționale, precum PostgreSQL, MySQL, SQL Server sau Oracle.

Exemple concrete de folosire:

  • Verificarea efectului: după ce plasezi o comandă din UI, verifici că rândul din orders are statusul, totalul și utilizatorul corect, iar în order_items sunt toate produsele.
  • Găsirea datelor de test: ai nevoie de un utilizator cu o comandă anulată și un cod de reducere expirat; un query te scutește de o oră de pregătire manuală.
  • Pregătirea datelor: inserezi sau modifici date ca să ajungi rapid într-o stare greu de obținut din interfață, de exemplu o factură scadentă de 30 de zile.
  • Investigarea bug-urilor: totalul afișat e greșit; verifici dacă valoarea e greșită deja în baza de date (problemă de backend) sau doar în afișare (problemă de frontend).
  • Verificarea migrărilor: după o migrare de date, compari numărul de rânduri și valorile cheie.
  • Integritate: înregistrări orfane, duplicate, valori NULL unde n-ar trebui.

La interviurile de QA se cer de obicei SELECT cu WHERE, JOIN-uri, GROUP BY, HAVING, funcții de agregare și uneori subinterogări. Nu ți se cere să fii administrator de baze de date, dar trebuie să scrii fluent query-uri de citire și să știi să modifici date în siguranță pe un mediu de test.

Regulă importantă: pe medii partajate sau pe producție lucrezi, de regulă, doar cu drepturi de citire.

Ce urmărește intervievatorul: Se verifică dacă vezi SQL ca unealtă de testare, nu doar ca materie. Greșeala tipică este un răspuns teoretic, fără exemple practice.

55 Junior

Scrie un query care afișează utilizatorii înregistrați azi, ordonați după ora înregistrării, cea mai recentă prima.

Răspuns scurt: Filtrezi coloana de dată pe intervalul zilei curente cu WHERE și sortezi descrescător cu ORDER BY. Folosirea unui interval, nu a unei funcții aplicate pe coloană, păstrează indexul utilizabil.

Presupunem tabela users(id, email, created_at), unde created_at e de tip timestamp. În PostgreSQL:

SQL
SELECT id, email, created_at
FROM users
WHERE created_at >= CURRENT_DATE
  AND created_at < CURRENT_DATE + INTERVAL '1 day'
ORDER BY created_at DESC;

În MySQL, varianta echivalentă:

SQL
SELECT id, email, created_at
FROM users
WHERE created_at >= CURDATE()
  AND created_at < CURDATE() + INTERVAL 1 DAY
ORDER BY created_at DESC;

De ce un interval și nu WHERE DATE(created_at) = CURRENT_DATE? Ambele dau același rezultat, dar aplicarea unei funcții pe coloană împiedică de obicei folosirea indexului pe created_at, deci pe o tabelă mare query-ul e mult mai lent. Pe o bază de test mică nu observi, dar e un detaliu pe care intervievatorii îl apreciază.

Alte observații utile:

  • ORDER BY ... DESC sortează descrescător; implicit e ASC;
  • evită SELECT * în query-urile pe care le salvezi sau le pui în teste: selectezi doar coloanele de care ai nevoie;
  • pentru primele 10 rezultate: LIMIT 10 în PostgreSQL și MySQL, TOP 10 sau FETCH FIRST 10 ROWS ONLY în SQL Server;
  • fusul orar contează: dacă created_at e salvat în UTC, iar „azi” înseamnă ziua din România, rezultatele pot diferi în primele ore ale zilei. E o sursă clasică de bug-uri pe care un QA ar trebui s-o testeze.

Ce urmărește intervievatorul: Intervievatorul verifică sintaxa de bază și atenția la detalii precum intervalele și fusul orar. Greșeala tipică este compararea unui timestamp direct cu o dată.

56 Junior

Care este diferența dintre INNER JOIN și LEFT JOIN? Cum găsești clienții care nu au plasat nicio comandă?

Răspuns scurt: INNER JOIN întoarce doar rândurile care au corespondent în ambele tabele, iar LEFT JOIN întoarce toate rândurile din tabela din stânga, cu NULL unde nu există corespondent. Clienții fără comenzi îi găsești cu LEFT JOIN și filtrarea pe NULL.

Să presupunem tabelele customers(id, name) și orders(id, customer_id, total).

INNER JOIN întoarce doar combinațiile care se potrivesc:

SQL
SELECT c.name, o.id AS order_id, o.total
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

Un client fără comenzi nu apare deloc. Un client cu trei comenzi apare de trei ori.

LEFT JOIN păstrează toate rândurile din tabela din stânga:

SQL
SELECT c.name, o.id AS order_id
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;

Clienții fără comenzi apar cu order_id NULL.

Clienții fără nicio comandă:

SQL
SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.id IS NULL;

Varianta cu NOT EXISTS e la fel de corectă și adesea mai clară:

SQL
SELECT c.id, c.name
FROM customers c
WHERE NOT EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id);

Alte tipuri: RIGHT JOIN e simetricul lui LEFT JOIN, iar FULL OUTER JOIN păstrează rândurile din ambele părți (nu e suportat în MySQL).

O capcană tipică: dacă adaugi o condiție pe tabela din dreapta în WHERE (de exemplu WHERE o.total > 100), LEFT JOIN se comportă de fapt ca INNER JOIN, pentru că rândurile cu NULL sunt eliminate. Condiția trebuie mutată în ON dacă vrei să păstrezi toți clienții.

Pentru un QA, LEFT JOIN cu IS NULL e foarte util la găsirea înregistrărilor orfane sau lipsă.

Ce urmărește intervievatorul: Se verifică înțelegerea JOIN-urilor, cea mai frecventă temă SQL la interviu. Greșeala tipică este încercarea de a găsi absența cu INNER JOIN.

57 Junior

Scrie un query care găsește adresele de email duplicate din tabela users.

Răspuns scurt: Grupezi după email cu GROUP BY și păstrezi doar grupurile cu mai mult de un rând folosind HAVING COUNT(*) > 1. Pentru a prinde și duplicatele care diferă prin majuscule sau spații, normalizezi emailul cu LOWER și TRIM.

Varianta de bază:

SQL
SELECT email, COUNT(*) AS aparitii
FROM users
GROUP BY email
HAVING COUNT(*) > 1
ORDER BY aparitii DESC;

Diferența dintre WHERE și HAVING e exact ce verifică întrebarea:

  • WHERE filtrează rândurile înainte de grupare și nu poate folosi funcții de agregare;
  • HAVING filtrează grupurile după grupare, deci poate folosi COUNT, SUM, AVG.

Ca tester, mergi un pas mai departe. „Ana@Example.com” și „ana@example.com ” sunt, practic, același email, dar query-ul de mai sus nu le vede ca duplicate:

SQL
SELECT LOWER(TRIM(email)) AS email_normalizat, COUNT(*) AS aparitii
FROM users
GROUP BY LOWER(TRIM(email))
HAVING COUNT(*) > 1;

Dacă găsești rezultate aici, ai probabil un bug: aplicația nu normalizează emailul la înregistrare, iar utilizatorul își poate crea două conturi.

Pentru a vedea rândurile complete ale duplicatelor:

SQL
SELECT u.*
FROM users u
JOIN (
  SELECT LOWER(TRIM(email)) AS e
  FROM users
  GROUP BY LOWER(TRIM(email))
  HAVING COUNT(*) > 1
) d ON LOWER(TRIM(u.email)) = d.e
ORDER BY LOWER(TRIM(u.email)), u.id;

Un alt detaliu: unele baze de date compară textul case-insensitive implicit, în funcție de colaționare (de exemplu multe colaționări din MySQL), altele nu (PostgreSQL). Merită să știi pe ce bază lucrezi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi GROUP BY și HAVING și dacă gândești ca un tester despre ce înseamnă „duplicat”. Greșeala tipică este folosirea WHERE COUNT(*) > 1.

58 Junior

Cum modifici în siguranță date pe un mediu de test folosind INSERT, UPDATE și DELETE?

Răspuns scurt: Rulezi întâi un SELECT cu aceeași condiție ca să vezi ce rânduri vei afecta, lucrezi într-o tranzacție pe care o poți anula cu ROLLBACK, verifici numărul de rânduri afectate și nu rulezi niciodată UPDATE sau DELETE fără WHERE.

Comenzile de modificare (DML):

  • INSERT INTO products (name, price) VALUES ('Mouse test', 49.99);
  • UPDATE orders SET status = 'SHIPPED' WHERE id = 1042;
  • DELETE FROM carts WHERE user_id = 77;

Un UPDATE sau DELETE fără WHERE afectează toate rândurile tabelei. Pe un mediu de test partajat, asta poate bloca o echipă întreagă. Obiceiurile care te protejează:

1. SELECT înainte de modificare, cu exact aceeași condiție:

SQL
SELECT id, status FROM orders WHERE id = 1042;

2. Tranzacție explicită:

SQL
BEGIN;
UPDATE orders SET status = 'SHIPPED' WHERE id = 1042;
-- baza raportează câte rânduri au fost afectate; mă aștept la 1
SELECT id, status FROM orders WHERE id = 1042;
COMMIT;   -- sau ROLLBACK; dacă rezultatul nu e cel așteptat

Atenție: unele clienturi SQL au autocommit activ. Fără BEGIN, fiecare comandă se salvează imediat.

3. Constrângerile și legăturile: ștergerea unui utilizator poate eșua din cauza cheilor străine sau poate șterge în cascadă comenzile lui. Verifică schema înainte.

4. Datele de test identificabile: folosește prefixe sau domenii dedicate (qa+...@example.com), ca să le găsești și să le ștergi ușor, fără să atingi datele altora.

5. Drepturile: pe medii partajate sau pe producție, QA lucrează de regulă doar cu drepturi de citire. Modificările acolo se fac prin aplicație sau prin scripturi revizuite.

În automatizare, pregătirea datelor prin API e de obicei preferabilă scrierii directe în baza de date, pentru că respectă regulile de business ale aplicației.

Ce urmărește intervievatorul: Se verifică prudența și disciplina de lucru cu date. Greșeala tipică este rularea unui UPDATE fără verificare prealabilă sau fără tranzacție.

59 Mid

După plasarea unei comenzi din interfață, cum verifici cu SQL că datele au fost salvate corect?

Răspuns scurt: Identific comanda după un ID sau un utilizator de test, apoi verific tabela principală (status, total, utilizator, dată) și tabelele legate (produse, plăți, stoc), comparând valorile cu ce am văzut în interfață și cu regulile de business.

Acesta e un exemplu tipic de testare grey box. Presupunem tabelele orders, order_items, products și payments.

1. Găsesc comanda. Folosesc ID-ul afișat în pagina de confirmare sau ultima comandă a utilizatorului de test:

SQL
SELECT id, user_id, status, total, created_at
FROM orders
WHERE user_id = 77
ORDER BY created_at DESC
LIMIT 1;

2. Verific liniile comenzii și totalul:

SQL
SELECT oi.product_id, p.name, oi.quantity, oi.unit_price,
       oi.quantity * oi.unit_price AS subtotal
FROM order_items oi
JOIN products p ON p.id = oi.product_id
WHERE oi.order_id = 5012;

SELECT o.total, SUM(oi.quantity * oi.unit_price) AS suma_liniilor
FROM orders o
JOIN order_items oi ON oi.order_id = o.id
WHERE o.id = 5012
GROUP BY o.total;

Totalul comenzii trebuie să corespundă sumei liniilor plus livrarea minus reducerile, conform regulilor.

3. Verific efectele secundare:

  • plata există, cu suma și statusul corect;
  • stocul produselor a scăzut cu cantitatea comandată;
  • prețul salvat în order_items e cel de la momentul comenzii, nu se schimbă dacă prețul produsului se modifică ulterior.

4. Caut ce nu ar trebui să existe: comenzi duplicate create în aceeași secundă (dublu click), linii cu cantitate zero, valori NULL în câmpuri obligatorii.

Ce merită spus: tipurile de date contează. Banii se stochează ca DECIMAL sau NUMERIC, nu ca FLOAT, din cauza erorilor de rotunjire. Dacă vezi totaluri ca 199.98999, ai găsit probabil un bug de design.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să validezi end-to-end, inclusiv efectele secundare. Greșeala tipică este verificarea doar a existenței rândului în tabela principală.

60 Mid

Care sunt capcanele valorii NULL în SQL? Ce întoarce COUNT(*) față de COUNT(coloană)?

Răspuns scurt: NULL înseamnă valoare necunoscută, deci orice comparație cu el, inclusiv = NULL, nu e adevărată; se folosește IS NULL. COUNT(*) numără toate rândurile, iar COUNT(coloană) doar rândurile în care coloana nu e NULL.

În SQL, NULL nu e zero și nu e șir gol, ci „valoare lipsă sau necunoscută”. De aici vine logica cu trei valori: o comparație poate fi TRUE, FALSE sau UNKNOWN.

Capcana 1: comparația cu =

SQL
SELECT * FROM users WHERE phone = NULL;   -- nu întoarce nimic
SELECT * FROM users WHERE phone IS NULL;  -- corect

Capcana 2: negația nu include NULL-urile

SQL
SELECT * FROM users WHERE country <> 'RO';

Utilizatorii fără țară completată nu apar, pentru că NULL <> 'RO' e UNKNOWN. Dacă îi vrei și pe ei, adaugi OR country IS NULL.

Capcana 3: agregările

  • COUNT(*) numără toate rândurile;
  • COUNT(phone) numără doar rândurile cu telefon completat;
  • AVG(rating) ignoră NULL-urile, deci media e calculată doar din evaluările existente, nu tratează lipsa ca zero.

Capcana 4: NOT IN cu o subinterogare care conține NULL

SQL
SELECT * FROM customers
WHERE id NOT IN (SELECT customer_id FROM orders);

Dacă măcar un customer_id din orders e NULL, query-ul nu întoarce niciun rând. NOT EXISTS nu are această problemă.

Capcana 5: operațiile aritmetice și concatenarea: price + NULL dă NULL. COALESCE(discount, 0) înlocuiește NULL cu o valoare implicită.

Pentru un QA, NULL-urile sunt o sursă bogată de bug-uri: rapoarte cu totaluri greșite, utilizatori care dispar din filtre, câmpuri opționale care strică exportul. Merită testate explicit.

Ce urmărește intervievatorul: Se verifică înțelegerea mai profundă a SQL, specifică nivelului mid. Greșeala tipică este folosirea = NULL sau surprinderea în fața lui NOT IN.

61 Mid

Ce este SQL injection și cum testezi dacă o aplicație este vulnerabilă?

Răspuns scurt: SQL injection apare când inputul utilizatorului e concatenat direct într-un query, permițând modificarea lui. Testezi trimițând caractere și fragmente SQL în câmpuri și parametri și urmărind erori, comportament neobișnuit sau date expuse; protecția corectă sunt query-urile parametrizate.

SQL injection e o vulnerabilitate clasică, inclusă în categoria „Injection” din OWASP Top 10. Apare când aplicația construiește query-ul prin concatenare:

JavaScript
// vulnerabil
const sql = "SELECT * FROM users WHERE email = '" + email + "'";

Dacă utilizatorul trimite ' OR '1'='1, query-ul devine:

SQL
SELECT * FROM users WHERE email = '' OR '1'='1'

Condiția e mereu adevărată, deci query-ul întoarce toți utilizatorii. În scenarii mai grave, atacatorul poate citi alte tabele sau modifica date.

Cum testezi, doar pe medii și aplicații pentru care ai permisiune:

  • trimiți un apostrof simplu ' în câmpuri de text, parametri din URL, headere și corpul JSON; o eroare de bază de date (sau un 500) e un semnal de alarmă;
  • încerci fragmente ca ' OR '1'='1' -- în câmpuri de căutare sau login;
  • compari răspunsurile pentru condiții adevărate și false (' AND '1'='1 vs ' AND '1'='2), pentru cazurile în care aplicația nu afișează erori (blind injection);
  • verifici că mesajele de eroare nu expun query-uri, nume de tabele sau stack trace-uri;
  • pentru acoperire mai largă, folosești unelte dedicate precum OWASP ZAP sau, cu acordul echipei de securitate, sqlmap.

Protecția corectă, pe care o poți menționa developerilor:

JavaScript
// parametrizat (exemplu cu node-postgres)
await client.query('SELECT * FROM users WHERE email = $1', [email]);

Query-urile parametrizate și ORM-urile folosite corect separă datele de cod. Validarea inputului ajută, dar nu înlocuiește parametrizarea. Testarea de securitate pe sisteme pentru care nu ai autorizare este ilegală.

Ce urmărește intervievatorul: Intervievatorul verifică conștiința de securitate de bază a unui QA. Greșeala tipică este credința că validarea în frontend e suficientă ca protecție.

JavaScript și Git pentru testeri

62 Junior

Ce comenzi Git folosești zilnic și de ce are nevoie un QA de Git?

Răspuns scurt: Zilnic folosesc git clone, status, pull, switch sau checkout pentru branch-uri, add, commit, push și log. Un QA are nevoie de Git pentru a versiona testele automate, a lucra prin pull requesturi și a testa exact branch-ul sau versiunea unei funcționalități.

Git este un sistem distribuit de control al versiunilor. Fiecare commit e o captură a fișierelor, cu autor, dată și mesaj. Un branch este o linie separată de lucru.

Un flux zilnic tipic:

BASH
git clone https://github.com/firma/teste-e2e.git   # o singură dată
git switch main && git pull                         # aduc ultimele schimbări
git switch -c test/checkout-coupon                  # branch nou pentru lucrul meu
# ... scriu sau modific teste ...
git status                                          # ce s-a schimbat
git add tests/checkout.spec.ts
git commit -m "Adaugă teste pentru coduri de reducere expirate"
git push -u origin test/checkout-coupon             # urc branch-ul

Alte comenzi utile: git log --oneline pentru istoric, git diff pentru diferențe, git stash pentru a pune deoparte temporar schimbări neterminate, git restore pentru a anula modificări locale. git switch există din Git 2.23; în echipe vei vedea des și git checkout, care face același lucru, plus altele.

De ce are nevoie un QA de Git:

  • testele automate sunt cod și se versionează, se revizuiesc și se îmbină ca orice alt cod;
  • poți rula aplicația sau testele pe branch-ul unui developer înainte de merge;
  • istoricul commiturilor te ajută să afli ce s-a schimbat între două versiuni, deci ce trebuie retestat;
  • pipeline-urile de CI pornesc de la evenimente Git (push, pull request).

Mesajele de commit bune explică ce și de ce, nu doar „fix” sau „update”. E un detaliu pe care intervievatorii îl observă la temele de casă.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat efectiv cu Git, nu doar ai citit despre el. Greșeala tipică este necunoașterea diferenței dintre commit local și push.

63 Junior

Care este diferența dintre var, let și const în JavaScript?

Răspuns scurt: var are scope de funcție și este ridicat (hoisted) cu valoarea undefined. let și const au scope de bloc și nu pot fi folosite înainte de declarare. const nu permite reasignarea, dar obiectele declarate cu const pot fi modificate.

Diferențele principale:

  • Scope: var e vizibil în toată funcția; let și const doar în blocul { } în care sunt declarate (if, for, funcție).
  • Hoisting: toate trei sunt „ridicate” la începutul scope-ului, dar var primește imediat valoarea undefined, pe când let și const stau în temporal dead zone până la linia declarației. Accesul înainte dă ReferenceError.
  • Reasignare: var și let permit, const nu.
  • Redeclarare în același scope: doar var permite.
JavaScript
console.log(a); // undefined
var a = 1;

// console.log(b); // ReferenceError
let b = 2;

const user = { name: 'Ana' };
user.name = 'Ioana';   // permis: obiectul se modifică
// user = {};          // TypeError: reasignare interzisă

Exemplul clasic de interviu, cu bucle:

JavaScript
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}
// afișează 3, 3, 3

for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}
// afișează 0, 1, 2

Cu var există o singură variabilă i, iar callback-urile o citesc după ce bucla s-a terminat. Cu let fiecare iterație are propria variabilă.

Recomandarea actuală: folosește implicit const, let când chiar ai nevoie de reasignare, și evită var. În testele automate, asta previne bug-uri greu de găsit legate de valori schimbate între pași.

Ce urmărește intervievatorul: Este o întrebare de bază pentru orice rol care scrie JavaScript. Se verifică înțelegerea scope-ului; greșeala tipică este afirmația că un obiect const nu poate fi modificat.

64 Junior

Care este diferența dintre == și === în JavaScript? Ce afișează 0 == "", null == undefined și NaN === NaN?

Răspuns scurt: == compară după conversia automată a tipurilor, iar === compară fără conversie, deci și tipul trebuie să coincidă. 0 == "" este true, null == undefined este true, iar NaN === NaN este false.

Egalitatea strictă === întoarce true doar dacă valorile au același tip și aceeași valoare. Egalitatea abstractă == încearcă întâi să convertească operanzii la un tip comun (type coercion), iar regulile sunt surprinzătoare:

JavaScript
console.log(0 == "");            // true  ("" devine 0)
console.log(0 == "0");           // true
console.log("" == "0");          // false (ambele sunt string, se compară direct)
console.log(null == undefined);  // true  (regulă specială)
console.log(null == 0);          // false
console.log(false == "0");       // true
console.log(NaN === NaN);        // false
console.log(Number.isNaN(NaN));  // true

Observă că == nici măcar nu e tranzitiv: 0 == "" și 0 == "0", dar "" != "0".

NaN (Not a Number) e singura valoare din JavaScript care nu e egală cu ea însăși. Pentru verificare se folosește Number.isNaN(), iar Object.is(NaN, NaN) întoarce true.

De ce contează pentru un QA:

  • în aserțiuni, compararea lui "42" (text dintr-un element de pagină) cu 42 (număr) cu == ar trece, ascunzând o diferență de tip care poate fi un bug în API;
  • în Jest și Playwright, expect(x).toBe(y) folosește Object.is, deci e strict, iar toEqual compară structura obiectelor recursiv;
  • valorile citite din interfață sunt aproape mereu string-uri; le convertești explicit cu Number() sau parseFloat() înainte de calcule.

Regula practică: folosește întotdeauna === și !==. Excepția acceptată de unele echipe este x == null, care prinde și null, și undefined.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi capcanele conversiei de tip. Greșeala tipică este presupunerea că NaN e egal cu el însuși.

65 Junior

Ce afișează următorul cod și de ce? (console.log, setTimeout, Promise, async/await)

Răspuns scurt: Afișează A, D, F, C, E, B. Codul sincron rulează primul, apoi microtask-urile (callback-urile promisiunilor și continuarea după await), iar abia apoi macrotask-urile precum setTimeout, chiar cu întârziere 0.

Codul:

JavaScript
console.log('A');

setTimeout(() => console.log('B'), 0);

Promise.resolve().then(() => console.log('C'));

(async () => {
  console.log('D');
  await null;
  console.log('E');
})();

console.log('F');

Rezultatul: A, D, F, C, E, B.

Explicația ține de event loop:

  • Codul sincron rulează integral, de sus în jos. A se afișează imediat. setTimeout programează un macrotask. .then programează un microtask, adică C. Funcția async începe sincron, deci D se afișează imediat, iar await suspendă funcția și programează restul ei (E) ca microtask, după C. Apoi se afișează F.
  • După terminarea codului sincron, motorul golește coada de microtask-uri în ordine: C, apoi E.
  • Abia apoi rulează următorul macrotask: B. setTimeout cu 0 înseamnă „cât mai curând după”, nu „imediat”.

De ce întreabă un intervievator asta pentru un rol de QA automation: Playwright și Selenium WebDriver pentru JavaScript sunt complet asincrone. Fiecare acțiune (click, fill, goto) întoarce un Promise. Dacă nu înțelegi ordinea de execuție, vei scrie teste care verifică ceva înainte ca acțiunea să se fi terminat, adică teste instabile sau, mai rău, teste care trec fără să verifice nimic.

La interviu, explică pas cu pas cozile, nu doar dă rezultatul final.

Ce urmărește intervievatorul: Se verifică înțelegerea asincronismului, fundamentul automatizării în JavaScript. Greșeala tipică este plasarea lui B înaintea lui C pentru că „timeout-ul e 0”.

66 Junior

Ce se întâmplă dacă uiți un await într-un test Playwright? Cum previi problema?

Răspuns scurt: Acțiunea pornește, dar testul nu așteaptă să se termine, așa că pașii următori rulează prea devreme, aserțiunile pot fi ignorate, iar testul poate trece fals sau pica aleator. O previi cu regula ESLint no-floating-promises și cu TypeScript.

În Playwright aproape toate metodele care interacționează cu pagina întorc un Promise. await suspendă execuția până la rezolvarea promisiunii și propagă erorile.

TypeScript
test('adaugă în coș', async ({ page }) => {
  await page.goto('/produse/mouse');
  page.getByRole('button', { name: 'Adaugă în coș' }).click(); // lipsește await
  expect(page.getByTestId('cart-count')).toHaveText('1');       // lipsește await
});

Ce se poate întâmpla:

  • click-ul pornește, dar următoarea linie rulează imediat;
  • aserțiunea toHaveText e asincronă (web-first); fără await, testul se termină înainte ca verificarea să aibă loc. Testul poate apărea verde fără să fi verificat nimic, cel mai periculos rezultat posibil;
  • dacă promisiunea eșuează ulterior, eroarea apare ca „unhandled rejection”, uneori atribuită altui test, sau ca eroare de tipul „target page, context or browser has been closed”;
  • comportamentul variază de la o rulare la alta: un test flaky clasic.

Varianta corectă:

TypeScript
await page.getByRole('button', { name: 'Adaugă în coș' }).click();
await expect(page.getByTestId('cart-count')).toHaveText('1');

Atenție la diferență: expect(valoare).toBe(x) pe o valoare deja obținută e sincron și nu are nevoie de await; aserțiunile pe locator sau pe page (toBeVisible, toHaveText, toHaveURL) au nevoie.

Prevenție:

  • regula @typescript-eslint/no-floating-promises semnalează orice promisiune neașteptată;
  • Playwright avertizează în unele cazuri despre aserțiuni neașteptate, dar nu te baza doar pe asta;
  • code review atent pe testele noi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai scris efectiv teste asincrone. Greșeala tipică este necunoașterea faptului că testul poate trece fals.

67 Mid

Ce diferență este între git merge și git rebase? Cum rezolvi un conflict?

Răspuns scurt: Merge combină două branch-uri și păstrează istoricul așa cum a fost, de obicei cu un commit de merge. Rebase mută commiturile tale peste vârful altui branch, rescriind istoricul liniar. Conflictul îl rezolvi editând fișierele marcate, apoi add și continuarea operației.

Să presupunem că ai lucrat pe test/login, iar între timp main a primit commituri noi.

Merge

BASH
git switch test/login
git merge main

Git creează un commit de merge care leagă cele două istorii. Nimic existent nu se rescrie, deci e sigur pe branch-uri partajate. Dezavantaj: istoricul poate deveni greu de citit cu multe merge-uri.

Rebase

BASH
git switch test/login
git rebase main

Git ia commiturile tale și le reaplică, unul câte unul, peste ultimul commit din main. Rezultatul e un istoric liniar. Commiturile tale primesc însă hash-uri noi, deci istoricul e rescris. Regula de aur: nu faci rebase pe un branch pe care lucrează și alții. După rebase pe branch-ul tău deja urcat, ai nevoie de git push --force-with-lease, varianta mai sigură a lui --force, care refuză suprascrierea dacă altcineva a urcat între timp.

Rezolvarea unui conflict. Apare când ambele părți au modificat aceleași linii. Git marchează fișierul:

<<<<<<< HEAD
await page.getByRole('button', { name: 'Intră în cont' }).click();
=======
await page.getByTestId('login-submit').click();
>>>>>>> main

Pașii:

  • decizi ce rămâne, uneori o combinație a ambelor, și ștergi marcajele;
  • rulezi testele afectate, ca să confirmi că rezolvarea e corectă;
  • git add fisier, apoi git commit (la merge) sau git rebase --continue (la rebase);
  • dacă te-ai încurcat, git merge --abort sau git rebase --abort te întorc la starea inițială.

Ce urmărește intervievatorul: Se verifică dacă știi să lucrezi în echipă pe același repository. Greșeala tipică este folosirea rebase și force push pe branch-uri partajate.

68 Mid

Cum arată un pull request bun pentru teste automate și la ce te uiți când revizuiești testele unui coleg?

Răspuns scurt: Un PR bun e mic, are o descriere clară (ce acoperă, cum se rulează, legătura cu tichetul) și trece în CI. La review verific dacă testele verifică ce trebuie, sunt independente și stabile, folosesc locatori robuști, nu au așteptări fixe și respectă structura proiectului.

Un pull request bun:

  • e mic și focalizat: un set de teste pentru o funcție, nu 40 de fișiere modificate;
  • are o descriere cu ce acoperă, legătura cu story-ul sau bug-ul, cum se rulează local și eventual o captură din raport;
  • trece toate verificările din CI (lint, testele noi, suita existentă);
  • nu conține fișiere generate: rapoarte, capturi, node_modules.

La review, mă uit la:

Corectitudine

  • testul chiar verifică criteriul de acceptare? Are aserțiuni relevante, nu doar navigare?
  • ar pica dacă funcția s-ar strica? Uneori modific intenționat valoarea așteptată ca să verific;

Stabilitate

  • fără waitForTimeout sau sleep cu timp fix;
  • locatori robuști (rol, label, test id), nu XPath lungi legați de structura paginii;
  • testul e independent: își creează datele și nu depinde de ordinea rulării;

Mentenabilitate

  • folosește Page Objects sau helperele existente, fără cod duplicat;
  • nume de teste care descriu comportamentul: „respinge codul expirat”, nu „test3”;
  • date de test clare, fără valori magice nedocumentate;

Securitate

  • nicio parolă sau token scrise direct în cod.

Cum formulez comentariile: concret și cu motiv („waitForTimeout(3000) poate face testul instabil pe CI; propun await expect(...).toBeVisible()”), cu diferența clară între ce e obligatoriu și ce e o sugestie. Scopul review-ului e un cod mai bun și o echipă care învață, nu demonstrarea cine știe mai mult.

Ce urmărește intervievatorul: Intervievatorul verifică dacă tratezi testele ca pe cod de producție. Greșeala tipică este un review superficial, limitat la stil.

69 Mid

Cum folosești map, filter și reduce în teste? Scrie o verificare că prețurile afișate sunt sortate crescător.

Răspuns scurt: map transformă fiecare element, filter păstrează elementele care respectă o condiție, iar reduce combină elementele într-o singură valoare. În teste le folosești pentru a transforma textele citite din pagină în date și a compara cu rezultatul așteptat.

Cele trei metode de array lucrează fără să modifice array-ul original:

JavaScript
const products = [
  { name: 'Mouse', price: 49.99, stock: 10 },
  { name: 'Tastatură', price: 129.5, stock: 0 },
  { name: 'Monitor', price: 899, stock: 3 },
];

const names = products.map(p => p.name);              // ['Mouse', 'Tastatură', 'Monitor']
const inStock = products.filter(p => p.stock > 0);    // Mouse și Monitor
const total = products.reduce((sum, p) => sum + p.price, 0); // 1078.49

Un exemplu tipic de test: după ce alegi „Preț crescător”, verifici că lista e sortată.

TypeScript
test('produsele sunt sortate după preț crescător', async ({ page }) => {
  await page.goto('/produse');
  await page.getByLabel('Sortează după').selectOption('pret-asc');
  await expect(page.getByTestId('product-price').first()).toBeVisible();

  const texts = await page.getByTestId('product-price').allTextContents();
  // de exemplu ["49,99 lei", "1.299,00 lei"]
  const prices = texts.map(t =>
    Number(t.replace(/[^\d,]/g, '').replace(',', '.'))
  );

  const sorted = [...prices].sort((a, b) => a - b);
  expect(prices).toEqual(sorted);
});

Detalii importante:

  • sort() modifică array-ul pe loc, de aceea fac o copie cu [...prices];
  • fără funcția de comparare, sort() compară ca text, iar [10, 9, 100] devine [10, 100, 9];
  • formatul românesc folosește punct pentru mii și virgulă pentru zecimale, deci conversia trebuie făcută explicit; e și un loc bun pentru bug-uri de localizare;
  • allTextContents() nu așteaptă elementele, de aceea aștept întâi ca primul preț să fie vizibil. Dacă lista se reîncarcă după sortare, e mai sigur să aștepți și un semn că sortarea s-a aplicat, de exemplu parametrul din URL.

Ce urmărește intervievatorul: Se verifică fluența în JavaScript aplicată la testare. Greșeala tipică este folosirea sort() fără funcție de comparare pe numere.

70 Mid

Cum găsești commitul care a introdus un bug, când știi doar că versiunea de acum o lună funcționa?

Răspuns scurt: Folosesc git bisect: marchez un commit bun și unul rău, iar Git face căutare binară prin istoric, cerându-mi să testez commitul din mijloc la fiecare pas. Pașii se pot automatiza cu git bisect run și un script de test.

git bisect caută commitul vinovat prin căutare binară. Dacă între versiunea bună și cea stricată sunt 200 de commituri, ai nevoie de aproximativ 8 pași (2 la puterea 8 = 256), nu de 200 de verificări.

Fluxul manual:

BASH
git bisect start
git bisect bad                 # commitul curent are bug-ul
git bisect good v2.3.0         # tag sau hash al unei versiuni care mergea
# Git trece pe un commit din mijloc. Construiești, testezi, apoi:
git bisect good                # dacă bug-ul nu apare
git bisect bad                 # dacă bug-ul apare
# ... repeți până când Git afișează primul commit rău ...
git bisect reset               # te întorci de unde ai plecat

Dacă un commit nu poate fi testat (de exemplu nu compilează), git bisect skip îl sare.

Varianta automată, dacă ai un test care reproduce bug-ul:

BASH
git bisect start HEAD v2.3.0
git bisect run npx playwright test tests/regresie/discount.spec.ts

Git rulează comanda la fiecare pas: cod de ieșire 0 înseamnă „bun”, între 1 și 127 (cu excepția lui 125, rezervat pentru „skip”) înseamnă „rău”.

Ca să funcționeze bine:

  • testul trebuie să existe și să fie același la fiecare pas; dacă e nou, ține-l într-un fișier în afara repository-ului sau necomis;
  • dependențele se pot schimba între commituri, deci uneori e nevoie de npm ci în script;
  • commiturile mici fac rezultatul mai precis.

Alternative mai simple: git log pe fișierele suspecte, git log -S "text" pentru a găsi când a apărut sau dispărut un fragment de cod și git blame pentru o linie anume.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să investighezi regresii eficient. Greșeala tipică este propunerea de a testa manual fiecare commit în parte.

71 Mid

Ce fișiere nu ar trebui să ajungă într-un repository de teste automate și cum gestionezi parolele și tokenurile?

Răspuns scurt: Nu se comit node_modules, rapoartele și artefactele de rulare (capturi, video, trace), fișierele .env și stările de autentificare salvate. Secretele se țin în variabile de mediu local și în secretele platformei de CI, iar .gitignore previne adăugarea lor accidentală.

Un .gitignore tipic pentru un proiect Playwright:

node_modules/
test-results/
playwright-report/
blob-report/
playwright/.cache/
playwright/.auth/
.env
*.log

De ce fiecare:

  • node_modules se reconstruiește din package.json și package-lock.json; lockfile-ul se comite, ca toată lumea să aibă aceleași versiuni (npm ci în CI);
  • rapoartele, capturile, video-urile și trace-urile sunt generate la fiecare rulare, ocupă mult spațiu și pot conține date sensibile;
  • playwright/.auth conține stări de autentificare salvate (cookie-uri, tokenuri), practic o sesiune activă;
  • .env conține secrete.

Gestionarea secretelor:

  • local, într-un fișier .env necomis, citit de exemplu cu pachetul dotenv, iar în repository se comite un .env.example cu numele variabilelor, fără valori;
  • în CI, în mecanismul de secrete al platformei (GitHub Actions secrets, GitLab CI variables marcate masked și protected), expuse testelor ca variabile de mediu;
  • în cod: process.env.TEST_USER_PASSWORD, niciodată valoarea scrisă direct.

Dacă un secret a ajuns totuși într-un commit, ștergerea lui într-un commit nou nu e suficientă, pentru că rămâne în istoric. Pașii corecți: revoci sau schimbi imediat secretul, apoi, dacă e necesar, cureți istoricul cu unelte precum git filter-repo. Prevenția include scanarea automată de secrete (de exemplu funcția de secret scanning din GitHub sau gitleaks).

Și conturile de test merită tratate ca reale: parole unice, drepturi minime.

Ce urmărește intervievatorul: Se verifică igiena de lucru și conștiința de securitate. Greșeala tipică este credința că ștergerea unui secret într-un commit nou îl face să dispară.

Automatizare cu Playwright și Selenium

72 Junior

Ce teste merită automatizate și ce teste e mai bine să rămână manuale?

Răspuns scurt: Merită automatizate testele repetitive și stabile: regresia, smoke-ul, fluxurile critice, verificările pe multe seturi de date și testele API. Rămân manuale testarea exploratorie, uzabilitatea, verificările vizuale subiective și funcțiile care se schimbă des sau se testează o singură dată.

Automatizarea are un cost de scriere și, mai ales, de întreținere. Merită când beneficiul repetat depășește acest cost.

Candidați buni pentru automatizare:

  • regresia pe fluxuri critice (login, căutare, checkout, plată), rulată la fiecare build;
  • smoke testul după fiecare deploy;
  • teste data-driven: aceeași verificare pe zeci de combinații de date;
  • testele API, care sunt rapide și stabile;
  • calcule și reguli de business cu multe variante;
  • verificări pe mai multe browsere;
  • teste care sunt greu de făcut manual corect: încărcare, concurență, verificări repetate pe durate lungi.

E mai bine să rămână manuale:

  • testarea exploratorie, unde valoarea vine din gândirea testerului;
  • uzabilitatea și experiența utilizatorului: e clar, e plăcut, e intuitiv?;
  • funcții încă instabile ca design, care se schimbă de la un sprint la altul;
  • teste rulate o singură dată sau foarte rar;
  • verificări care cer judecată umană: conținut, ton, calitatea unei imagini.

Criterii de decizie: cât de des rulezi testul, cât de stabilă e funcția, ce risc acoperă, cât costă să-l scrii și să-l întreții, cât de deterministic e rezultatul.

Ideea importantă: automatizarea nu înlocuiește testerul. Testele automate verifică ce le-ai spus să verifice, și doar atât. Ele eliberează timp pentru testarea care cere gândire. Un răspuns care spune „automatizez tot” e un semnal de alarmă pentru intervievator.

Ce urmărește intervievatorul: Intervievatorul verifică judecata privind costul și beneficiul automatizării. Greșeala tipică este „automatizăm 100%”.

73 Junior

Care sunt principalele diferențe dintre Playwright și Selenium?

Răspuns scurt: Selenium folosește protocolul WebDriver, standard W3C, și suportă multe limbaje și browsere, fiind foarte matur. Playwright comunică direct cu browserele, are auto-waiting, runner propriu, izolare prin browser contexts, interceptarea rețelei și unelte de depanare incluse.

Selenium WebDriver există din anii 2000 și e cel mai răspândit instrument de automatizare web.

  • folosește protocolul WebDriver, standardizat de W3C, prin drivere specifice fiecărui browser (chromedriver, geckodriver); din Selenium 4.6, Selenium Manager descarcă automat driverele;
  • suportă Java, Python, C#, JavaScript, Ruby, Kotlin;
  • e doar o bibliotecă: runnerul de teste, raportarea și structura le alegi tu (JUnit, TestNG, pytest, Mocha);
  • Selenium Grid permite rularea distribuită, iar ecosistemul și comunitatea sunt foarte mari;
  • Selenium 4 adaugă suport pentru WebDriver BiDi, un protocol bidirecțional nou.

Playwright a fost lansat de Microsoft în 2020.

  • controlează Chromium, Firefox și WebKit (motorul Safari) prin protocoale proprii, cu versiuni de browser aduse de Playwright;
  • suportă JavaScript/TypeScript, Python, Java și .NET; runnerul complet Playwright Test există pentru JavaScript și TypeScript;
  • auto-waiting: înainte de un click, așteaptă ca elementul să fie vizibil, stabil și activ;
  • aserțiuni web-first care reîncearcă până la timeout;
  • browser contexts: sesiuni izolate și foarte ieftine, deci teste independente în paralel;
  • interceptarea rețelei, emulare de dispozitive, testare API, trace viewer, codegen și UI mode incluse.

Când alegi ce: Playwright e de obicei mai rapid de pornit și mai stabil pentru aplicații web moderne. Selenium e potrivit când echipa are deja o investiție mare în el, când ai nevoie de un limbaj suportat doar de Selenium sau de browsere reale specifice. Pentru aplicații mobile native, niciunul nu e potrivit direct; se folosește Appium, care preia protocolul WebDriver.

Ce urmărește intervievatorul: Se verifică dacă cunoști uneltele dincolo de nume și poți argumenta o alegere. Greșeala tipică este prezentarea uneia ca fiind „mai bună” în orice situație.

74 Junior

Ce este un locator și ce face ca un locator să fie bun? Compară CSS, XPath și locatorii bazați pe rol.

Răspuns scurt: Un locator e modul prin care testul găsește un element în pagină. Un locator bun e unic, stabil la schimbări de layout și apropiat de felul în care utilizatorul vede pagina: rol și nume accesibil, label, text sau un atribut de test dedicat.

Locatorii sunt cauza principală a testelor fragile. Dacă testul depinde de structura exactă a paginii, orice refactorizare de frontend îl strică.

Ordinea de preferință recomandată de documentația Playwright:

TypeScript
page.getByRole('button', { name: 'Trimite comanda' });
page.getByLabel('Adresă de email');
page.getByPlaceholder('Caută produse');
page.getByText('Comanda a fost plasată');
page.getByTestId('cart-total');            // implicit atributul data-testid
page.locator('#checkout-form .total');     // CSS
page.locator('//div[@class="row"][3]/span'); // XPath, de evitat

Locatorii bazați pe rol și label reflectă ce vede utilizatorul și ce citește un cititor de ecran. Bonus: dacă nu poți găsi un buton după rol și nume, probabil ai găsit și o problemă de accesibilitate.

data-testid e un contract explicit între developeri și testeri. Nu se schimbă la redesign, dar presupune ca echipa să adauge atributele.

CSS: rapid și ușor de citit. Bun cu id-uri stabile sau atribute; slab cu clase generate automat (de exemplu css-1x2y3z) sau cu lanțuri lungi.

XPath: poate face lucruri pe care CSS nu le poate (navigare spre părinte, căutare după text în versiunile mai vechi de Selenium), dar XPath-urile absolute sau bazate pe poziție (/html/body/div[2]/div[3]) se strică la orice schimbare.

În Selenium, echivalentele sunt By.id, By.cssSelector, By.xpath, By.name; nu există locatori nativi după rol, deci id, atributele de test și CSS-ul simplu sunt preferate.

Regula: un locator trebuie să fie unic. Playwright are mod strict și aruncă eroare dacă un locator folosit pentru o acțiune găsește mai multe elemente.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să scrii teste stabile. Greșeala tipică este folosirea XPath-urilor absolute copiate din DevTools.

75 Junior

Ce tipuri de așteptări există în Selenium și de ce Thread.sleep sau un timp fix de așteptare este o practică proastă?

Răspuns scurt: Selenium are așteptări implicite (timp global pentru găsirea elementelor), explicite (WebDriverWait până la o condiție) și fluente (explicite cu interval de verificare și excepții ignorate). Un sleep fix fie pierde timp, fie e prea scurt, deci produce teste lente și instabile.

Aplicațiile web moderne încarcă date asincron, deci elementele apar, se schimbă și dispar după momentul în care pagina pare încărcată. Testul trebuie să aștepte o condiție, nu un timp.

Implicit wait: o setare globală. Când caută un element, driverul reîncearcă până la timpul setat. Ajută doar la găsirea elementelor, nu la vizibilitate sau la posibilitatea de a da click.

Explicit wait: aștepți o condiție anume pentru un element anume. Exemplu cu Selenium pentru JavaScript (pachetul selenium-webdriver):

JavaScript
const { Builder, By, until } = require('selenium-webdriver');

const driver = await new Builder().forBrowser('chrome').build();
await driver.get('https://test.exemplu.ro/login');
await driver.findElement(By.id('email')).sendKeys('qa@example.com');
await driver.findElement(By.id('submit')).click();

const banner = await driver.wait(until.elementLocated(By.css('.welcome')), 10000);
await driver.wait(until.elementIsVisible(banner), 10000);

În Java, echivalentul este new WebDriverWait(driver, Duration.ofSeconds(10)).until(ExpectedConditions.elementToBeClickable(By.id("submit"))).

Fluent wait: o așteptare explicită la care configurezi și intervalul de verificare și excepțiile ignorate între încercări.

Documentația Selenium recomandă să nu amesteci așteptările implicite cu cele explicite, pentru că pot produce timpi de așteptare imprevizibili.

De ce Thread.sleep(3000) e o practică proastă:

  • dacă elementul apare în 300 ms, pierzi 2,7 secunde; înmulțit cu sute de teste, suita devine foarte lentă;
  • dacă pe CI aplicația răspunde în 4 secunde, testul pică; ai un test flaky;
  • ascunde problema reală în loc s-o exprime clar: „aștept ca mesajul de confirmare să fie vizibil”.

Playwright rezolvă mare parte din problemă prin auto-waiting, dar principiul rămâne: aștepți stări, nu secunde.

Ce urmărește intervievatorul: Se verifică una dintre cauzele principale ale testelor instabile. Greșeala tipică este folosirea sleep-urilor „ca să meargă”.

76 Junior

Ce înseamnă auto-waiting și aserțiunile web-first în Playwright?

Răspuns scurt: Auto-waiting înseamnă că, înainte de o acțiune, Playwright așteaptă ca elementul să fie atașat, vizibil, stabil, activ și să primească evenimente. Aserțiunile web-first, precum toBeVisible sau toHaveText, reîncearcă automat până când condiția e îndeplinită sau expiră timpul.

Auto-waiting. Când scrii await page.getByRole('button', { name: 'Plătește' }).click(), Playwright nu dă click imediat. Verifică întâi, în mod repetat, condițiile de actionability: elementul există în DOM, e vizibil, e stabil (nu se animă), primește evenimente (nu e acoperit de alt element) și e activ (nu e disabled). Pentru fill, verifică în plus că elementul e editabil. Dacă toate sunt îndeplinite înainte de timeout, execută acțiunea; altfel testul pică cu un mesaj care spune exact ce condiție nu a fost îndeplinită.

Aserțiunile web-first aplică aceeași idee la verificări:

TypeScript
await expect(page.getByText('Comanda a fost plasată')).toBeVisible();
await expect(page.getByTestId('cart-count')).toHaveText('2');
await expect(page).toHaveURL(/\/confirmare/);

Fiecare aserțiune reîncearcă până devine adevărată sau până la timeout-ul pentru expect (implicit 5 secunde, configurabil în playwright.config.ts).

Diferența față de o verificare „manuală”:

TypeScript
// fragil: citește textul o singură dată, poate prea devreme
expect(await page.getByTestId('cart-count').textContent()).toBe('2');

// robust: reîncearcă până când textul devine 2
await expect(page.getByTestId('cart-count')).toHaveText('2');

Prima variantă e o cauză foarte frecventă de teste flaky, pentru că textul poate fi încă „1” în momentul citirii.

Limitele: auto-waiting nu știe când s-a terminat logica ta de business. Dacă după un click pagina face un request și abia apoi actualizează lista, trebuie să aștepți explicit rezultatul vizibil (o aserțiune) sau răspunsul (page.waitForResponse). Evită page.waitForTimeout, pe care documentația îl recomandă doar pentru depanare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul care face testele Playwright stabile. Greșeala tipică este citirea textului cu textContent și compararea imediată.

77 Junior

Scrie un test Playwright care verifică un login reușit și unul eșuat.

Răspuns scurt: Navighezi la pagina de login, completezi câmpurile găsite după label, apeși butonul găsit după rol, apoi verifici cu aserțiuni web-first URL-ul și mesajul de bun venit, respectiv mesajul de eroare și faptul că rămâi pe pagina de login.

Un exemplu cu Playwright Test, în TypeScript, presupunând că baseURL este setat în configurație și credențialele vin din variabile de mediu:

TypeScript
import { test, expect } from '@playwright/test';

test.describe('Login', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/login');
  });

  test('utilizatorul valid ajunge în contul său', async ({ page }) => {
    await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!);
    await page.getByLabel('Parolă').fill(process.env.TEST_USER_PASSWORD!);
    await page.getByRole('button', { name: 'Intră în cont' }).click();

    await expect(page).toHaveURL(/\/contul-meu/);
    await expect(page.getByRole('heading', { name: /Bun venit/ })).toBeVisible();
  });

  test('parola greșită afișează o eroare generică', async ({ page }) => {
    await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!);
    await page.getByLabel('Parolă').fill('parola-gresita');
    await page.getByRole('button', { name: 'Intră în cont' }).click();

    await expect(page.getByRole('alert')).toHaveText('Email sau parolă incorecte');
    await expect(page).toHaveURL(/\/login/);
  });
});

Ce merită explicat la interviu:

  • beforeEach evită repetarea navigării, iar fiecare test primește automat un page nou, într-un context izolat;
  • locatorii după label și rol sunt rezistenți la schimbări de design;
  • nicio așteptare fixă: aserțiunile web-first așteaptă singure;
  • testul negativ verifică două lucruri: apare eroarea și utilizatorul nu a fost autentificat;
  • ! din TypeScript spune compilatorului că variabila există; în proiectele reale e mai sigur să validezi la pornire că variabilele de mediu sunt setate.

Rulezi cu npx playwright test, iar npx playwright test --ui deschide modul interactiv, util la depanare. Într-un proiect mai mare, login-ul se mută într-un Page Object, iar celelalte teste refolosesc o sesiune salvată.

Ce urmărește intervievatorul: Se verifică dacă poți scrie cod de test funcțional, curat, pe loc. Greșeala tipică este folosirea sleep-urilor și a selectorilor fragili sau lipsa aserțiunilor.

78 Junior

Cum structurezi un test automat? Explică Arrange–Act–Assert și hook-urile beforeEach și afterEach.

Răspuns scurt: Un test bun are trei părți: Arrange pregătește datele și starea, Act execută acțiunea testată, Assert verifică rezultatul. Hook-urile beforeEach și afterEach rulează cod comun înainte și după fiecare test, de exemplu navigarea sau curățarea datelor.

Arrange–Act–Assert (AAA) e un tipar care face testele ușor de citit și de depanat:

TypeScript
test('codul de reducere expirat este respins', async ({ page, request }) => {
  // Arrange: pregătesc datele și ajung în starea de start
  await request.post('/api/test/coupons', {
    data: { code: 'EXPIRAT10', expiresAt: '2020-01-01' },
  });
  await page.goto('/cos');

  // Act: acțiunea testată
  await page.getByLabel('Cod de reducere').fill('EXPIRAT10');
  await page.getByRole('button', { name: 'Aplică' }).click();

  // Assert: rezultatul așteptat
  await expect(page.getByRole('alert')).toHaveText('Codul a expirat');
});

(Endpointul de creare a cuponului e un exemplu de API de test pe care multe echipe îl expun doar pe mediile de test.)

Reguli care decurg din AAA:

  • o singură acțiune principală pe test; dacă ai mai multe secțiuni Act, probabil ai două teste;
  • aserțiunile verifică un singur comportament, chiar dacă folosești mai multe expect;
  • numele testului descrie comportamentul, nu pașii.

Hook-urile din Playwright Test (similare cu Jest și Mocha):

  • test.beforeEach și test.afterEach: înainte și după fiecare test din fișier sau din describe;
  • test.beforeAll și test.afterAll: o singură dată per worker, pentru setup costisitor.

Atenție la capcane:

  • beforeAll creează stare partajată între teste, care poate duce la dependențe ascunse și probleme la rularea în paralel;
  • logica de business ascunsă în hook-uri face testul greu de înțeles; păstrează în hook doar ce e cu adevărat comun;
  • în Playwright, pentru setup reutilizabil, fixture-urile sunt de obicei o alegere mai bună decât hook-urile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii teste lizibile și independente. Greșeala tipică este un test lung care verifică zece lucruri diferite.

79 Mid

Ce este Page Object Model? Arată un exemplu în Playwright.

Răspuns scurt: Page Object Model este un tipar de design în care fiecare pagină sau componentă are o clasă cu locatorii și acțiunile ei. Testele folosesc metodele clasei, deci o schimbare în interfață se repară într-un singur loc, nu în zeci de teste.

Fără un tipar, locatorii și pașii se repetă în fiecare test. Când designul paginii de login se schimbă, trebuie modificate 50 de fișiere. Page Object Model (POM) mută detaliile de interfață într-o clasă.

TypeScript
// pages/LoginPage.ts
import { Page, Locator, expect } from '@playwright/test';

export class LoginPage {
  readonly page: Page;
  readonly email: Locator;
  readonly password: Locator;
  readonly submit: Locator;
  readonly error: Locator;

  constructor(page: Page) {
    this.page = page;
    this.email = page.getByLabel('Email');
    this.password = page.getByLabel('Parolă');
    this.submit = page.getByRole('button', { name: 'Intră în cont' });
    this.error = page.getByRole('alert');
  }

  async goto() {
    await this.page.goto('/login');
  }

  async login(email: string, password: string) {
    await this.email.fill(email);
    await this.password.fill(password);
    await this.submit.click();
  }
}
TypeScript
// tests/login.spec.ts
import { test, expect } from '@playwright/test';
import { LoginPage } from '../pages/LoginPage';

test('eroare la parolă greșită', async ({ page }) => {
  const login = new LoginPage(page);
  await login.goto();
  await login.login('qa@example.com', 'gresit');
  await expect(login.error).toHaveText('Email sau parolă incorecte');
});

Bune practici:

  • Page Object-ul conține locatori și acțiuni; aserțiunile stau de preferință în teste, ca testul să arate clar ce verifică;
  • metodele descriu intenția utilizatorului (login, applyCoupon), nu clicuri individuale;
  • pentru componente refolosite (header, coș lateral) creezi obiecte separate, compuse în pagini;
  • nu transforma POM într-o ierarhie complicată de moșteniri; compoziția e mai ușor de întreținut.

În Playwright, Page Object-urile se pot injecta prin fixture-uri personalizate, ca testele să nu le mai instanțieze manual.

Ce urmărește intervievatorul: Este o întrebare aproape obligatorie la automation. Se verifică dacă înțelegi scopul (mentenabilitatea), nu doar structura; greșeala tipică este punerea tuturor aserțiunilor în Page Object.

80 Mid

Ce sunt testele flaky, care sunt cauzele lor și cum le repari?

Răspuns scurt: Un test flaky trece și pică alternativ pe același cod. Cauzele frecvente sunt așteptările greșite, dependența de date sau de ordinea testelor, starea partajată, mediul instabil și serviciile externe. Le repari identificând cauza cu trace-uri și rulări repetate, nu prin retry-uri.

Un test flaky dă rezultate diferite fără vreo schimbare de cod. Efectul e grav: echipa încetează să mai aibă încredere în suită și începe să ignore testele roșii, inclusiv pe cele care semnalează bug-uri reale.

Cauze frecvente:

  • timing: așteptări fixe, citiri de text înainte de actualizare, animații, request-uri încă în desfășurare;
  • date: teste care folosesc același utilizator sau aceeași comandă și se calcă pe picioare la rularea în paralel; date create de un alt test;
  • ordinea: testul B merge doar dacă A a rulat înainte;
  • mediul: mediu de test lent sau supraîncărcat, resurse limitate în CI;
  • servicii externe instabile: plăți, emailuri, hărți;
  • bug-uri reale de concurență în aplicație. Nu orice test flaky e vina testului.

Cum le investighezi și repari:

  • rulezi testul repetat local: npx playwright test login.spec.ts --repeat-each=20, eventual cu mai mulți workeri, ca să reproduci condițiile din CI;
  • activezi trace-ul (trace: 'on-first-retry') și îl analizezi în Trace Viewer: vezi DOM-ul, rețeaua și consola la fiecare pas;
  • înlocuiești așteptările fixe cu aserțiuni web-first sau cu așteptarea răspunsului de rețea relevant;
  • faci fiecare test independent, cu date proprii, create prin API;
  • simulezi serviciile externe cu page.route() acolo unde nu ele sunt obiectul testului.

Proces: retry-urile în CI ascund simptomul și sunt acceptabile doar temporar. Un test cunoscut ca flaky se marchează vizibil (de exemplu test.fixme sau o etichetă de carantină), primește un tichet și un responsabil și se repară într-un termen stabilit.

Ce urmărește intervievatorul: Intervievatorul verifică experiența reală cu automatizarea în CI. Greșeala tipică este soluția „pun retry-uri” sau „măresc timeout-ul”.

81 Mid

Ce sunt fixture-urile în Playwright și cum eviți să faci login prin interfață în fiecare test?

Răspuns scurt: Fixture-urile sunt resurse pe care Playwright le pregătește pentru test și le curăță după, de exemplu page, context sau request; poți defini și fixture-uri proprii. Pentru login, autentifici o dată într-un proiect de setup, salvezi starea cu storageState și o refolosești în toate testele.

Fixture-urile sunt mecanismul prin care un test primește ce îi trebuie, declarat în parametri: async ({ page, request }) => { ... }. Playwright creează doar fixture-urile cerute, le izolează pe test și le curăță la final. Poți crea propriile fixture-uri cu test.extend:

TypeScript
// fixtures.ts
import { test as base } from '@playwright/test';
import { LoginPage } from './pages/LoginPage';

export const test = base.extend<{ loginPage: LoginPage }>({
  loginPage: async ({ page }, use) => {
    const loginPage = new LoginPage(page);
    await loginPage.goto();
    await use(loginPage);
    // codul de după use rulează la final, pentru curățare
  },
});
export { expect } from '@playwright/test';

Testele importă apoi test din fixtures.ts și primesc direct loginPage.

Login reutilizat cu storageState. A te autentifica prin interfață în fiecare test e lent și adaugă un punct de eșec în teste care nu verifică login-ul. Abordarea recomandată de documentație:

TypeScript
// tests/auth.setup.ts
import { test as setup, expect } from '@playwright/test';
const authFile = 'playwright/.auth/user.json';

setup('autentificare', async ({ page }) => {
  await page.goto('/login');
  await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!);
  await page.getByLabel('Parolă').fill(process.env.TEST_USER_PASSWORD!);
  await page.getByRole('button', { name: 'Intră în cont' }).click();
  await expect(page).toHaveURL(/\/contul-meu/);
  await page.context().storageState({ path: authFile });
});

În playwright.config.ts, un proiect setup cu testMatch: /.*\.setup\.ts/, iar proiectele de browser au dependencies: ['setup'] și use: { storageState: 'playwright/.auth/user.json' }. Cookie-urile și local storage-ul sunt încărcate automat în fiecare context nou.

Directorul playwright/.auth se adaugă în .gitignore. Pentru teste care modifică starea contului, folosește conturi separate pe worker, ca testele paralele să nu interfereze.

Ce urmărește intervievatorul: Se verifică dacă știi să construiești teste rapide și reutilizabile. Greșeala tipică este login prin UI în fiecare test sau partajarea unui singur cont între teste paralele care îl modifică.

82 Mid

Cum lucrezi în Playwright cu iframe-uri, ferestre noi, dialoguri și încărcarea de fișiere?

Răspuns scurt: Pentru iframe folosești frameLocator, pentru tab-uri noi aștepți evenimentul popup, dialogurile le tratezi cu page.on("dialog"), iar fișierele le încarci cu setInputFiles. Esențial e să pornești așteptarea evenimentului înainte de acțiunea care îl declanșează.

Aceste situații apar des la formularele de plată, autentificarea externă sau exporturile.

Iframe-uri (de exemplu câmpurile de card ale unui procesator de plăți):

TypeScript
const payment = page.frameLocator('iframe[title="Plată securizată"]');
await payment.getByLabel('Număr card').fill('4242 4242 4242 4242');

Numărul de mai sus este un card de test publicat de Stripe, folosit doar în modul de test. În versiunile recente există și locator.contentFrame(), cu același efect.

Tab-uri sau ferestre noi:

TypeScript
const popupPromise = page.waitForEvent('popup');
await page.getByRole('link', { name: 'Termeni și condiții' }).click();
const popup = await popupPromise;
await expect(popup).toHaveURL(/termeni/);

Ordinea contează: începi să aștepți evenimentul înainte de click, altfel îl poți rata.

Dialoguri (alert, confirm, prompt). Implicit, Playwright le închide automat. Ca să le verifici sau să le accepți:

TypeScript
page.once('dialog', async dialog => {
  expect(dialog.message()).toContain('Sigur ștergi');
  await dialog.accept();
});
await page.getByRole('button', { name: 'Șterge contul' }).click();

Încărcare de fișiere:

TypeScript
await page.getByLabel('Încarcă CV').setInputFiles('tests/data/cv.pdf');

Pentru un selector de fișiere deschis dintr-un buton personalizat, aștepți evenimentul filechooser.

Descărcări:

TypeScript
const downloadPromise = page.waitForEvent('download');
await page.getByRole('button', { name: 'Exportă CSV' }).click();
const download = await downloadPromise;
expect(download.suggestedFilename()).toMatch(/\.csv$/);

În Selenium, echivalentele sunt driver.switchTo().frame(), getWindowHandles() pentru ferestre și switchTo().alert() pentru dialoguri.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu situațiile mai dificile din automatizare. Greșeala tipică este pornirea așteptării evenimentului după click.

83 Mid

Cum configurezi Playwright pentru rulare paralelă, pe mai multe browsere, cu retry-uri și trace-uri?

Răspuns scurt: În playwright.config.ts setezi fullyParallel și numărul de workeri, definești proiecte pentru fiecare browser sau dispozitiv, activezi retry-uri doar în CI și trace-uri la prima reîncercare. Pentru suite mari, împarți rularea pe mai multe mașini cu sharding.

O configurație tipică:

TypeScript
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 2 : undefined,
  reporter: [['html'], ['junit', { outputFile: 'results/junit.xml' }]],
  use: {
    baseURL: process.env.BASE_URL ?? 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
    { name: 'mobile', use: { ...devices['Pixel 7'] } },
  ],
});

Ce face fiecare parte:

  • workers: procese separate care rulează teste simultan. Implicit, Playwright rulează fișierele în paralel, iar testele dintr-un fișier secvențial; fullyParallel: true paralelizează și în interiorul fișierelor. Condiția e ca testele să fie independente;
  • forbidOnly: pică build-ul dacă cineva a uitat un test.only în cod;
  • retries: în CI, un test picat se reîncearcă. Testele care trec doar la reîncercare apar în raport ca „flaky”, ceea ce e o informație, nu o rezolvare;
  • trace: înregistrează acțiunile, DOM-ul, rețeaua și consola. Se deschide cu npx playwright show-trace sau din raportul HTML;
  • projects: aceleași teste rulează pe mai multe configurații; poți rula unul singur cu --project=firefox.

Pentru suite mari, sharding-ul împarte testele pe mai multe mașini:

BASH
npx playwright test --shard=1/4

Rapoartele parțiale (reporterul blob) se combină apoi cu npx playwright merge-reports. Numărul de workeri în CI se alege după resursele runnerului și ale mediului testat, nu cât mai mare.

Ce urmărește intervievatorul: Se verifică dacă ai configurat un proiect real, nu doar ai scris teste. Greșeala tipică este folosirea retry-urilor ca soluție permanentă pentru instabilitate.

84 Mid

Ce este StaleElementReferenceException în Selenium și cum o eviți?

Răspuns scurt: Excepția apare când folosești o referință la un element care nu mai e atașat la DOM, de obicei pentru că pagina sau componenta s-a re-randat. O eviți căutând elementul din nou chiar înainte de folosire și așteptând starea stabilă a paginii.

În Selenium, findElement întoarce o referință la un nod concret din DOM. Dacă după aceea JavaScript-ul paginii înlocuiește acel nod (re-randare React, actualizarea unui tabel după filtrare, navigare), referința devine „stale” (învechită). Următoarea acțiune pe ea aruncă StaleElementReferenceException, chiar dacă vizual pe ecran există un element identic.

Exemplu tipic:

JavaScript
const rows = await driver.findElements(By.css('table tbody tr'));
await driver.findElement(By.id('filter-active')).click(); // tabelul se re-randează
await rows[0].click(); // StaleElementReferenceException

Cum o eviți:

  • cauți elementul din nou după acțiunea care schimbă pagina, în loc să păstrezi referințe vechi în variabile sau în câmpuri ale Page Object-ului;
  • în Page Object, păstrezi locatorii (By), nu elementele găsite, și le cauți la fiecare folosire;
  • aștepți explicit ca pagina să ajungă în starea nouă înainte de a căuta: de exemplu, că vechiul element a dispărut cu until.stalenessOf(element), apoi că noul conținut e vizibil;
  • un retry limitat în jurul acțiunii poate ajuta pentru componente care se re-randează imprevizibil, dar nu înlocuiește înțelegerea cauzei.
JavaScript
const firstRow = await driver.findElement(By.css('table tbody tr'));
await driver.findElement(By.id('filter-active')).click();
await driver.wait(until.stalenessOf(firstRow), 5000);
const newFirstRow = await driver.wait(
  until.elementLocated(By.css('table tbody tr')), 5000);
await newFirstRow.click();

Merită spus la interviu că Playwright nu are această problemă în forma clasică: un Locator e o descriere a modului de căutare, iar elementul se rezolvă din nou la fiecare acțiune.

Ce urmărește intervievatorul: Intervievatorul verifică experiența practică cu Selenium și înțelegerea DOM-ului. Greșeala tipică este „rezolvarea” prin sleep-uri.

85 Senior

Cum gestionezi datele de test într-o suită automată mare care rulează în paralel pe un mediu partajat?

Răspuns scurt: Fiecare test își creează datele de care are nevoie, de preferință prin API, cu identificatori unici, și nu depinde de datele altor teste. Datele statice de referință se pregătesc prin seed-uri versionate, iar curățarea se face controlat sau prin medii efemere.

Datele de test sunt una dintre cele mai frecvente surse de instabilitate la scară. Principiile pe care le aplic:

1. Independența testelor. Fiecare test își creează starea necesară și nu presupune ce a lăsat în urmă alt test. Astfel testele pot rula în orice ordine și în paralel.

2. Crearea datelor prin API, nu prin UI. Un test care verifică anularea unei comenzi nu are nevoie să parcurgă tot checkout-ul din interfață. Creează comanda printr-un endpoint, apoi testează anularea în UI. E mai rapid și mai stabil.

3. Identificatori unici. Emailuri și nume generate (qa+${Date.now()}-${workerIndex}@example.com), ca două teste paralele să nu creeze același utilizator. Biblioteci precum @faker-js/faker ajută la date realiste.

4. Tipuri diferite de date, strategii diferite:

  • date de referință (țări, categorii, configurări): seed versionat în repository, aplicat la crearea mediului;
  • date create de test: create și eventual șterse de test, într-un fixture care face curățarea după use;
  • conturi cu stare specială (blocat, premium): pool de conturi dedicate, câte unul pe worker.

5. Curățarea. Ștergerea după fiecare test pare ideală, dar eșuează când testul pică la jumătate. O alternativă robustă: date marcate clar (prefix, domeniu dedicat) și un job periodic care le șterge.

6. Mediile efemere. Cea mai curată soluție, dacă infrastructura o permite: un mediu nou, cu baza de date populată din seed, pentru fiecare pull request (de exemplu cu containere Docker), distrus după rulare.

La nivel senior, discuția e despre cost: mediile efemere cer investiție în infrastructură, deci aleg soluția pe măsura problemei.

Ce urmărește intervievatorul: Se verifică experiența la scară și gândirea arhitecturală. Greșeala tipică este folosirea acelorași conturi și date fixe pentru toate testele.

86 Senior

Trebuie să construiești de la zero un framework de automatizare pentru o aplicație web. Cum îl proiectezi?

Răspuns scurt: Pornesc de la nevoi și riscuri, aleg unealta după stack și echipă, definesc structura (configurație pe medii, Page Objects sau componente, fixture-uri, date de test, helperi API), integrez de la început CI și raportarea, încep cu fluxurile critice și stabilesc convenții și ownership.

Aș trata frameworkul ca pe un produs intern, cu utilizatori (echipa) și cerințe.

1. Înțeleg contextul. Ce aplicație (SPA, server-rendered, mobil), ce limbaj folosesc developerii, cine va scrie și întreține testele, ce browsere contează, cum arată mediile și pipeline-ul existent, care sunt fluxurile critice.

2. Aleg unealta. Pentru o aplicație web modernă cu echipă JavaScript sau TypeScript aș alege de obicei Playwright Test, pentru stabilitate, viteză, testare API inclusă și unelte de depanare. Aș alege altceva dacă echipa e pe Java și vrea același limbaj, sau dacă există deja o investiție mare în Selenium.

3. Structura:

tests/          teste grupate pe domenii de business
pages/          Page Objects și componente refolosite
fixtures/       fixture-uri: pagini, autentificare, date
api/            clienți API pentru setup și verificări
data/           seed-uri și fabrici de date de test
config/         configurații pe medii, citite din variabile de mediu

4. Principii: teste independente, date create prin API, locatori bazați pe rol și test id, fără așteptări fixe, secretele doar în variabile de mediu, TypeScript și ESLint (inclusiv no-floating-promises).

5. CI de la prima zi. Testele rulează pe fiecare pull request, cu raport HTML, trace-uri la eșec, notificări și politică pentru testele flaky.

6. Livrare incrementală. Încep cu smoke-ul și câteva fluxuri critice, demonstrez valoarea, apoi extind. Evit sute de teste scrise rapid și imposibil de întreținut.

7. Oameni și convenții. README cu cum rulezi și cum scrii un test, șabloane, code review obligatoriu, developerii pot contribui. Măsor durata, stabilitatea și defectele prinse, ca să știu dacă frameworkul își face treaba.

Ce urmărește intervievatorul: La nivel senior se verifică dacă gândești automatizarea ca arhitectură și proces, nu doar ca scripturi. Greșeala tipică este concentrarea exclusivă pe unealtă.

Strategie de testare, CI și calitate

87 Junior

Ce este piramida testelor și de ce contează pentru automatizare?

Răspuns scurt: Piramida testelor recomandă multe teste unitare la bază, mai puține teste de integrare și API la mijloc și puține teste end-to-end prin interfață în vârf. Testele de jos sunt rapide, stabile și ieftine, cele de sus sunt lente, fragile și scumpe de întreținut.

Modelul a fost popularizat de Mike Cohn și apare în aproape orice discuție despre strategia de automatizare.

        /  E2E / UI  \        puține: fluxuri critice
       /  Integrare   \       API, servicii, baze de date
      /    Unitare     \      multe: logică izolată

De ce această formă:

  • testele unitare rulează în milisecunde, nu depind de mediu și îți arată exact funcția cu problema;
  • testele de integrare și API verifică dacă piesele comunică corect, sunt încă rapide și destul de stabile;
  • testele end-to-end prin interfață sunt cele mai apropiate de experiența utilizatorului, dar sunt lente, depind de tot sistemul și pică din multe motive, nu doar din cauza unui bug.

Antitiparul frecvent este „conul de înghețată”: foarte multe teste manuale și UI, puține teste unitare. Rezultatul: suite care durează ore, rezultate instabile și bug-uri găsite târziu.

Ce înseamnă în practică pentru un QA:

  • o regulă de business (calculul unei reduceri cu 20 de variante) se testează la nivel unitar sau API, nu prin 20 de teste UI;
  • prin interfață testezi câteva fluxuri complete critice și ce ține strict de UI;
  • discuți cu developerii unde lipsesc teste unitare, în loc să compensezi cu teste UI.

Merită menționat că există și modele alternative, precum „testing trophy” (popularizat de Kent C. Dodds), care pune accentul pe testele de integrare. Ideea comună rămâne: fiecare verificare se face la nivelul cel mai jos la care poate fi făcută cu încredere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi unde să pui fiecare test. Greșeala tipică este automatizarea tuturor verificărilor prin interfață.

88 Mid

Cum integrezi testele automate într-un pipeline CI? Dă un exemplu cu GitHub Actions.

Răspuns scurt: Configurezi un workflow care rulează la fiecare pull request și push pe main: instalează dependențele și browserele, rulează testele cu variabilele și secretele mediului și publică raportul ca artefact. Rezultatul blochează merge-ul dacă testele pică.

CI (Continuous Integration) înseamnă că fiecare schimbare e integrată și verificată automat, des. Pentru testele automate, asta înseamnă feedback în minute, nu la final de sprint.

Un workflow minimal pentru Playwright, în .github/workflows/e2e.yml:

YAML
name: e2e
on:
  pull_request:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: lts/*
          cache: npm
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test
        env:
          BASE_URL: ${{ vars.BASE_URL }}
          TEST_USER_PASSWORD: ${{ secrets.TEST_USER_PASSWORD }}
      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: playwright-report
          path: playwright-report/
          retention-days: 14

Ce merită explicat:

  • npm ci instalează exact versiunile din lockfile;
  • --with-deps instalează și bibliotecile de sistem de care au nevoie browserele;
  • secretele vin din setările repository-ului, nu din cod;
  • raportul se urcă și când testele pică, altfel n-ai ce analiza;
  • cu branch protection, un pull request nu poate fi îmbinat dacă jobul pică.

Strategia pe etape, pentru un feedback rapid:

  • la fiecare pull request: lint, teste unitare, teste API și un smoke UI;
  • după deploy pe mediul de test: suita de regresie completă, eventual cu sharding;
  • programat (de exemplu noaptea, cu on: schedule): suite lungi, cross-browser, performanță.

În GitLab CI sau Jenkins conceptele sunt aceleași, doar sintaxa diferă.

Ce urmărește intervievatorul: Se verifică dacă știi să faci testele utile echipei, nu doar să le rulezi local. Greșeala tipică este punerea secretelor direct în fișierul de workflow.

89 Mid

Care este diferența dintre load, stress, spike și soak testing? Ce unelte folosești?

Răspuns scurt: Load testing verifică sistemul la încărcarea așteptată, stress testing îl împinge peste limite ca să vezi unde și cum cedează, spike testing verifică creșteri bruște, iar soak testing verifică stabilitatea pe durată lungă. Unelte uzuale: k6, JMeter, Gatling, Locust.

Toate sunt tipuri de testare de performanță, dar răspund la întrebări diferite:

  • Load testing: sistemul se comportă bine la încărcarea normală și la vârful așteptat? Măsori timpii de răspuns, rata de erori și consumul de resurse.
  • Stress testing: ce se întâmplă peste limită? Cauți punctul în care sistemul cedează și, la fel de important, dacă cedează controlat (mesaje clare, fără pierdere de date) și dacă își revine după.
  • Spike testing: creștere bruscă de utilizatori, de exemplu la începutul unei campanii de reduceri sau după o notificare trimisă tuturor.
  • Soak (endurance) testing: încărcare moderată pe multe ore. Găsește scurgeri de memorie, conexiuni neînchise, loguri care umplu discul.

Un exemplu cu k6, unde scenariile se scriu în JavaScript:

JavaScript
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 50 },
    { duration: '5m', target: 50 },
    { duration: '1m', target: 0 },
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
  const res = http.get('https://test.exemplu.ro/api/products');
  check(res, { 'status 200': (r) => r.status === 200 });
  sleep(1);
}

Pragurile din exemplu sunt ilustrative; valorile reale vin din cerințele nefuncționale ale produsului. Se folosesc percentile (p95, p99), nu media, pentru că media ascunde utilizatorii care așteaptă mult.

Reguli importante: testele se rulează pe un mediu cât mai apropiat de producție, niciodată pe producție sau pe sisteme terțe fără acord, iar rezultatele se compară cu o linie de bază măsurată anterior.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi tipurile și metricile corecte. Greșeala tipică este folosirea mediei timpului de răspuns ca singur indicator.

90 Mid

Cum testezi accesibilitatea unei aplicații web?

Răspuns scurt: Combin verificări automate (de exemplu axe-core integrat în Playwright sau Lighthouse) cu verificări manuale: navigare doar din tastatură, cititor de ecran, contrast, zoom, texte alternative și etichete. Ca referință folosesc ghidurile WCAG, nivelul AA.

Accesibilitatea înseamnă că aplicația poate fi folosită și de persoane cu dizabilități vizuale, auditive, motorii sau cognitive. Standardul de referință este WCAG (Web Content Accessibility Guidelines), versiunea 2.2 fiind publicată în 2023, cu niveluri A, AA și AAA; cerința uzuală este AA. În Uniunea Europeană, Actul european privind accesibilitatea (European Accessibility Act) se aplică din iunie 2025 pentru multe produse și servicii digitale, inclusiv magazine online, deci subiectul a devenit și unul legal.

Verificări automate prind problemele mecanice: contrast insuficient, imagini fără alt, câmpuri fără etichetă, atribute ARIA greșite.

TypeScript
import { test, expect } from '@playwright/test';
import AxeBuilder from '@axe-core/playwright';

test('pagina de checkout nu are încălcări WCAG A/AA detectabile automat', async ({ page }) => {
  await page.goto('/checkout');
  const results = await new AxeBuilder({ page })
    .withTags(['wcag2a', 'wcag2aa'])
    .analyze();
  expect(results.violations).toEqual([]);
});

Verificări manuale, pentru că uneltele automate nu pot judeca tot:

  • tastatura: parcurgi pagina doar cu Tab, Shift+Tab, Enter, Space și Escape; focusul e vizibil, ordinea e logică, nu rămâi blocat într-un modal;
  • cititor de ecran: NVDA pe Windows, VoiceOver pe macOS și iOS, TalkBack pe Android; butoanele au nume clare, erorile din formulare sunt anunțate;
  • zoom la 200% și text mărit, fără pierdere de conținut;
  • informația nu e transmisă doar prin culoare;
  • textele alternative sunt utile, nu doar prezente.

Un bonus pentru automatizare: dacă folosești locatori getByRole și getByLabel, testele tale semnalează deja indirect multe probleme de accesibilitate.

Ce urmărește intervievatorul: Se verifică dacă ai o imagine largă asupra calității, inclusiv a cerințelor legale. Greșeala tipică este credința că o scanare automată e suficientă.

91 Senior

Intri ca primul QA într-o echipă care nu a avut testare structurată. Cum construiești strategia de testare?

Răspuns scurt: Încep prin a înțelege produsul, utilizatorii, riscurile și durerile actuale, apoi stabilesc rapid o plasă de siguranță pe fluxurile critice, definesc o strategie scurtă (niveluri, tipuri, automatizare, medii, criterii) și introduc practicile treptat, cu echipa, măsurând efectul.

Aș evita să vin cu un proces complet din prima săptămână. Planul meu:

Primele 2–4 săptămâni: înțeleg.

  • produsul, utilizatorii, modelul de business: unde se pierd bani sau clienți dacă ceva se strică;
  • arhitectura, mediile, pipeline-ul, testele existente (inclusiv cele unitare);
  • istoricul: ce incidente au fost în producție, de unde vin reclamațiile, ce module se strică des;
  • cum lucrează echipa: cum se scriu cerințele, cum se face release-ul.

Repede: o plasă de siguranță.

  • o listă de fluxuri critice și un smoke test, întâi manual, apoi automatizat;
  • un format comun de bug report și un flux minim de triere.

Strategia, într-un document scurt:

  • ce riscuri sunt prioritare;
  • ce se testează la fiecare nivel: ce acoperă developerii prin teste unitare, ce se testează pe API, ce prin UI;
  • ce teste nefuncționale sunt necesare (performanță, securitate, accesibilitate) și când;
  • medii și date de test;
  • unealta de automatizare și integrarea în CI;
  • criteriile de intrare și ieșire, adică Definition of Ready și Definition of Done;
  • cum raportăm calitatea.

Introducerea treptată. Aleg una sau două schimbări cu impact mare (de exemplu criterii de acceptare clare și smoke automat în CI), le aplic, arăt rezultatul, apoi continui. Fiecare schimbare o discut cu echipa în retrospective, ca să fie a echipei, nu a mea.

Mesajul central: calitatea e responsabilitatea întregii echipe. Primul QA nu poate și nu trebuie să devină singurul filtru între cod și producție; rolul lui e să construiască un sistem în care echipa livrează cu încredere.

Ce urmărește intervievatorul: La nivel senior se verifică dacă știi să construiești de la zero, cu prioritizare și influență. Greșeala tipică este propunerea unui proces greu, impus din prima zi.

92 Senior

Suita de regresie automată durează acum peste o oră în CI. Cum o faci mai rapidă fără să pierzi încredere?

Răspuns scurt: Măsor întâi unde se pierde timpul, apoi elimin testele redundante, mut verificările la nivel API sau unitar, înlocuiesc setup-ul prin UI cu setup prin API, elimin așteptările fixe, paralelizez cu workeri și sharding și rulez selectiv la pull request, cu suita completă programat.

O suită lentă rulează rar și ajunge ignorată. Abordarea mea pornește de la date, nu de la presupuneri.

1. Măsor. Raportul arată durata fiecărui test și fișier. De obicei o mică parte a testelor consumă o mare parte din timp. Mă uit și la timpul pierdut în afara testelor: instalare, pornirea mediului, retry-uri.

2. Elimin și comasez.

  • teste duplicate sau care verifică același lucru pe căi diferite;
  • teste care n-au mai prins nimic de mult și acoperă zone cu risc mic;
  • verificări de logică făcute prin UI care pot fi mutate pe API sau la nivel unitar, cu acordul developerilor.

3. Accelerez testele rămase.

  • setup prin API în loc de pași UI: autentificare cu storageState, date create prin endpointuri;
  • eliminarea așteptărilor fixe și a navigărilor inutile;
  • blocarea resurselor irelevante (analytics, chat, reclame) cu page.route(), când nu ele sunt testate.

4. Paralelizez.

  • fullyParallel și mai mulți workeri, după ce testele sunt independente;
  • sharding pe mai multe mașini;
  • atenție la limita mediului testat: prea mulți workeri pot încetini aplicația și pot crea instabilitate.

5. Rulez selectiv.

  • la pull request: smoke-ul plus testele etichetate pentru zonele atinse (de exemplu --grep @checkout) sau testele din fișierele modificate (--only-changed din versiunile recente de Playwright);
  • suita completă după merge pe main și programat.

6. Mă protejez de pierderea încrederii. Urmăresc defectele scăpate în producție înainte și după schimbări. Dacă scad durata, dar cresc defectele scăpate, am tăiat prea mult. Încrederea vine din acoperirea riscurilor, nu din numărul de teste.

Ce urmărește intervievatorul: Intervievatorul verifică experiența de optimizare la scară și judecata. Greșeala tipică este doar „adăugăm mai mulți workeri”.

93 Senior

Cum construiești o cultură în care calitatea este responsabilitatea întregii echipe, nu doar a QA?

Răspuns scurt: Fac calitatea vizibilă și ușor de practicat: QA implicat de la rafinare, criterii de acceptare comune, teste în Definition of Done, quality gates automate în CI, developeri care testează și scriu teste, iar QA ca facilitator și coach, nu ca ultimul filtru.

Într-o echipă în care QA e „poarta de la final”, developerii livrează mai repede spre testare, iar QA devine blocajul. Schimbarea ține de obiceiuri, unelte și mesaj.

Practici care mută calitatea mai devreme:

  • three amigos și criterii de acceptare scrise împreună;
  • testele automate fac parte din Definition of Done pentru fiecare story;
  • developerii scriu teste unitare și de integrare, iar QA le revizuiește din perspectiva riscului;
  • pair testing: un developer și un QA testează împreună funcția înainte de a o declara gata;
  • sesiuni de testare exploratorie în echipă (bug bash) înainte de release-urile mari.

Quality gates automate în CI, care nu depind de o persoană:

  • lint și analiză statică;
  • teste unitare, API și smoke care trebuie să treacă înainte de merge;
  • eventual praguri convenite de acoperire pe codul nou sau scanări de securitate a dependențelor.

Vizibilitate:

  • raportul testelor e accesibil tuturor;
  • incidentele din producție se analizează fără vinovați (blameless postmortem), cu întrebarea „ce proces ar fi prins asta?”;
  • câteva metrici urmărite ca tendință, discutate în retrospective.

Rolul QA se schimbă: de la executant la coach. Construiește unelte și framework-uri ușor de folosit de developeri, învață echipa tehnici de design al testelor, se concentrează pe riscuri și pe testarea exploratorie complexă.

Cum o fac concret: încep cu o problemă pe care echipa o simte, de exemplu bug-urile găsite târziu, propun o singură practică, o încercăm două sprinturi și decidem în retrospectivă dacă o păstrăm. Cultura nu se impune prin reguli, ci prin rezultate pe care echipa le vede.

Ce urmărește intervievatorul: La nivel senior se verifică influența asupra echipei și înțelegerea modelului „whole team quality”. Greșeala tipică este prezentarea QA ca singurul responsabil cu calitatea.

94 Senior

Cum testezi o funcționalitate care depinde de timp, de procesare asincronă (cozi, joburi programate) sau de trimiterea de emailuri?

Răspuns scurt: Fac comportamentul controlabil și observabil: ceas simulat sau date setate în trecut pentru logica de timp, așteptare pe condiție (polling cu timeout) pentru procesarea asincronă și o căsuță de email de test interceptată pentru notificări, plus verificarea cazurilor de eroare și de reîncercare.

Astfel de funcții sunt greu de testat pentru că rezultatul nu apare imediat sau depinde de momentul rulării. Principiul general: faci sistemul controlabil și observabil în mediul de test.

Logica dependentă de timp (expirări, abonamente, rapoarte lunare):

  • în browser, Playwright are API-ul page.clock (din versiunea 1.45), care permite setarea și avansarea timpului: await page.clock.install({ time: new Date('2026-12-31T23:59:00') });
  • pe backend, ideal codul primește ceasul ca dependență injectabilă, sau există un mod de a crea date „în trecut” (o factură emisă acum 31 de zile);
  • testezi explicit: miezul nopții, ultima zi a lunii, anul bisect, schimbarea orei de vară, fusuri orare diferite.

Procesarea asincronă (cozi de mesaje, joburi, webhooks):

  • nu aștepți un timp fix; interoghezi periodic starea până la un timeout:
TypeScript
await expect.poll(async () => {
  const res = await request.get(`/api/exports/${exportId}`);
  return (await res.json()).status;
}, { timeout: 30_000 }).toBe('COMPLETED');
  • testezi eșecurile: ce se întâmplă dacă jobul pică, dacă mesajul e procesat de două ori (idempotență), dacă serviciul extern răspunde târziu;
  • verifici că există observabilitate: loguri și alerte pentru mesajele care eșuează repetat.

Emailuri și notificări:

  • pe mediile de test emailurile se trimit către o unealtă de captare, precum Mailpit sau MailHog (locale) ori un serviciu dedicat testării, care expun un API;
  • testul citește emailul prin API, verifică subiectul, conținutul și linkurile și poate urma linkul de confirmare;
  • verifici că pe mediile de test nu pleacă niciun email către adrese reale.

La nivel de strategie, aceste cerințe de testabilitate se discută cu developerii la design, nu după implementare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să testezi sisteme reale, nedeterministe, și să ceri testabilitate. Greșeala tipică este așteptarea cu timp fix sau testarea doar a cazului fericit.

Comportamentale și HR

95 Junior

De ce vrei să lucrezi ca QA Engineer?

Răspuns scurt: Un răspuns bun leagă motivația de natura muncii: îți place să înțelegi cum funcționează un produs, să găsești ce poate merge prost și să ajuți echipa să livreze ceva în care utilizatorii au încredere, plus interesul pentru partea tehnică, de automatizare.

Intervievatorul vrea să afle dacă alegerea e asumată sau dacă vezi QA doar ca „o ușă de intrare în IT” pe care vrei s-o părăsești cât mai repede. Ambele situații există, dar al doilea mesaj spus direct nu ajută.

O structură simplă pentru răspuns:

  • ce te atrage la muncă: curiozitatea, plăcerea de a investiga, atenția la detalii, perspectiva utilizatorului;
  • o dovadă: ceva concret ce ai făcut deja;
  • direcția: ce vrei să înveți în continuare.

Exemplu de răspuns:

„M-a atras testarea pentru că îmi place să înțeleg cum funcționează un produs în întregime și să mă gândesc la ce poate merge prost, nu doar la cazul fericit. În cursul de testare manuală am testat o aplicație demo de e-commerce și am găsit, de exemplu, că puteam aplica de două ori același cod de reducere dacă dădeam click rapid. Mi-a plăcut să investighez în DevTools ce se întâmplă și să scriu un raport clar. Acum învăț Playwright și am un proiect pe GitHub cu teste pentru fluxul de login și coș, rulate în GitHub Actions. Vreau să cresc spre un rol în care combin testarea exploratorie cu automatizarea.”

Ce funcționează:

  • exemple reale, chiar dacă vin din proiecte personale sau cursuri;
  • un proiect public pe care intervievatorul îl poate deschide;
  • legătura cu experiența anterioară, dacă vii din altă meserie: din relații cu clienții, contabilitate sau producție aduci perspectiva utilizatorului, rigoare sau gândirea pe proces.

Ce să eviți: răspunsuri generice („sunt atent la detalii”) fără dovezi și formulări care sugerează că testarea e o etapă temporară.

Ce urmărește intervievatorul: Se verifică motivația și dacă alegerea e informată. Greșeala tipică este un răspuns generic, fără exemplu, sau prezentarea QA ca soluție temporară.

96 Junior

Povestește despre cel mai interesant bug pe care l-ai găsit.

Răspuns scurt: Folosește metoda STAR: contextul, ce ai observat, cum ai investigat și izolat problema, cum ai raportat-o și ce impact a avut, plus ce ai învățat. Contează mai mult raționamentul decât spectaculozitatea bug-ului.

Întrebarea verifică modul în care investighezi și comunici. Metoda STAR te ajută să nu te pierzi în detalii:

  • Situație: proiectul și contextul, pe scurt;
  • Task: ce aveai de făcut;
  • Acțiune: ce ai observat, cum ai investigat, cum ai raportat; aici e partea cea mai importantă;
  • Rezultat: ce s-a întâmplat după și ce ai învățat.

Exemplu de structură:

„Situație: testam un modul de rezervări pentru o aplicație de programări, înainte de release. Task: verificam afișarea intervalelor libere. Acțiune: am observat că uneori un interval rezervat apărea în continuare liber. Nu se reproducea constant, așa că am notat orele la care apărea și am observat că se întâmpla doar pentru rezervările făcute după ora 21. Am verificat în baza de date și am văzut că ora era salvată în UTC, iar filtrarea pe zi se făcea pe data în UTC, deci rezervările de seară ajungeau în ziua următoare. Am scris un bug report cu pașii, query-ul folosit și două exemple concrete. Rezultat: developerul a reparat filtrarea, iar eu am adăugat în regresie teste pentru orele de după miezul nopții UTC și pentru trecerea la ora de vară. Am învățat să testez sistematic tot ce ține de timp și fus orar.”

Ce face povestea convingătoare:

  • arată metoda: tipar observat, ipoteză, verificare;
  • arată unelte reale: DevTools, SQL, loguri;
  • arată impactul și ce ai schimbat pe termen lung;
  • e povestea ta. Dacă ești la început, folosește un exemplu din proiecte personale sau din curs și spune asta deschis.

Ce urmărește intervievatorul: Intervievatorul verifică gândirea de investigație și comunicarea. Greșeala tipică este descrierea bug-ului fără a explica cum a fost găsit și izolat.

97 Mid

Povestește o situație în care nu ai fost de acord cu echipa sau cu product ownerul. Cum ai gestionat-o?

Răspuns scurt: Alege o situație reală în care ai susținut o poziție cu date, ai ascultat argumentele celeilalte părți, ai propus o soluție sau un compromis și ai acceptat decizia finală, chiar dacă nu era a ta. Încheie cu rezultatul și ce ai învățat.

Intervievatorul nu caută pe cineva care nu are niciodată conflicte, ci pe cineva care le gestionează matur. Ca QA vei avea des opinii diferite: despre severitatea unui bug, despre lansarea cu riscuri, despre ce intră în sprint.

Structura STAR, cu accent pe comunicare:

„Situație: cu două zile înainte de release, am găsit că exportul de facturi în PDF afișa greșit diacriticele pentru o parte din clienți. Product ownerul voia să lanseze, pentru că funcția principală a release-ului era alta. Task: trebuia să mă asigur că decizia se ia cu informații complete. Acțiune: în loc să insist doar pe „e un bug grav”, am adunat date: am verificat câte tipuri de facturi sunt afectate și am arătat un exemplu concret de factură care ar fi ajuns la un client. Am întrebat cât de des e folosit exportul și am aflat de la echipa de suport că e folosit zilnic. Am propus două variante: amânarea release-ului cu o zi sau lansarea cu exportul vechi activ printr-un feature flag. Rezultat: echipa a ales varianta cu feature flag, iar corectura a ajuns în release-ul următor. Am învățat că argumentele bazate pe impactul pentru utilizator funcționează mult mai bine decât cele bazate pe severitatea tehnică.”

Principii de subliniat:

  • discuți problema, nu persoana;
  • vii cu date și cu soluții, nu doar cu obiecții;
  • asculți: uneori cealaltă parte are informații pe care tu nu le ai;
  • respecți decizia luată, chiar dacă nu e a ta, și documentezi riscul asumat.

Evită exemplele în care „ai avut dreptate și ceilalți au greșit”, povestite cu reproș.

Ce urmărește intervievatorul: Se verifică maturitatea în conflict și capacitatea de a influența cu argumente. Greșeala tipică este o poveste în care candidatul pare rigid sau îi învinovățește pe alții.

98 Mid

Un bug pe care trebuia să-l prinzi a ajuns în producție. Ce ai făcut?

Răspuns scurt: Un răspuns bun arată asumare fără autoflagelare: ai ajutat imediat la evaluarea impactului și la reproducere, ai verificat corectura, apoi ai analizat de ce a scăpat și ai schimbat ceva concret în proces sau în teste ca să nu se repete.

Orice QA cu experiență are un astfel de episod. Întrebarea verifică dacă îți asumi, dacă reacționezi bine sub presiune și dacă înveți.

Structura recomandată:

  • ce s-a întâmplat, pe scurt și sincer;
  • reacția imediată: ce ai făcut ca impactul să fie cât mai mic;
  • analiza cauzei: de ce testarea nu l-a prins;
  • schimbarea: ce s-a modificat în proces sau în teste;
  • ce ai învățat.

Exemplu:

„După un release, câțiva clienți au raportat că nu pot finaliza comanda cu o anumită metodă de plată pe Safari mobil. Testasem plata, dar doar pe Chrome desktop și pe emulare mobilă. Am reprodus rapid problema pe un iPhone real, am atașat la tichet pașii și eroarea din consolă, iar developerul a identificat o funcție JavaScript nesuportată de versiunea respectivă de Safari. După hotfix am verificat corectura pe mai multe dispozitive. În analiza de după am propus două schimbări: am adăugat proiectul WebKit în suita Playwright pentru fluxul de checkout și am introdus în checklistul de release verificarea pe un dispozitiv iOS real pentru plăți. Am învățat să întreb devreme care sunt dispozitivele și browserele reale ale utilizatorilor, nu să presupun.”

Ce contează:

  • asumare: „nu am testat pe Safari”, nu „developerul a greșit”;
  • calm și acțiune: ai ajutat la rezolvare, nu doar ai explicat;
  • îmbunătățire sistemică: o schimbare care previne o clasă de bug-uri, nu doar acel caz;
  • recunoașterea faptului că testarea reduce riscul, dar nu îl elimină, fără să pară o scuză.

Ce urmărește intervievatorul: Intervievatorul verifică asumarea și învățarea din greșeli. Greșeala tipică este fie negarea oricărei greșeli, fie mutarea vinei pe alții.

99 Mid

Cum înveți rapid un domeniu sau o aplicație nouă când intri într-un proiect?

Răspuns scurt: Combin explorarea directă a aplicației cu documentația, testele și tichetele existente, discuții scurte cu product ownerul, developerii și suportul și notițe structurate (o hartă a funcțiilor și o listă de întrebări). Încep să aduc valoare devreme, prin teste pe zone mici.

Ca QA, adesea trebuie să înțelegi produsul mai bine decât oricine altcineva din echipă, inclusiv fluxurile rar folosite. Un răspuns bun arată o metodă, nu doar „citesc documentația”.

Abordarea mea:

Prima săptămână: explorare structurată.

  • folosesc aplicația ca un utilizator nou, cu sesiuni scurte de testare exploratorie pe câte o zonă;
  • construiesc o hartă a produsului: module, roluri de utilizatori, fluxuri principale, integrări externe;
  • notez tot ce nu înțeleg într-o listă de întrebări, pe care o parcurg apoi cu cine știe.

Surse de informații:

  • documentația, specificațiile și designurile, cu grijă, pentru că pot fi învechite;
  • testele existente, manuale și automate, care arată ce comportament e considerat corect;
  • tichetele de bug recente și cele de la suport, care arată unde sunt problemele reale și ce îi doare pe utilizatori;
  • discuții scurte cu product ownerul (de ce există funcția), cu developerii (cum e construită) și cu suportul (ce întreabă clienții).

Domeniul de business. Dacă e un domeniu specializat, precum asigurări, logistică sau plăți, învăț terminologia de bază și regulile principale, eventual din standarde sau reglementări publice.

Aduc valoare devreme. Încep cu sarcini mici: testarea unui story, actualizarea unor cazuri de test învechite, un bug bine documentat. Fiecare îmi lărgește harta.

Las ceva în urmă. Harta și întrebările clarificate devin o pagină de onboarding pentru următorul coleg.

Un exemplu concret din experiența ta, chiar dintr-un curs sau proiect personal, face răspunsul mult mai credibil.

Ce urmărește intervievatorul: Se verifică autonomia și metoda de învățare, importante într-o meserie în care schimbi des proiecte. Greșeala tipică este un răspuns pasiv, de tipul „aștept să mi se explice”.

100 Senior

Cum ai convinge managementul să investească în automatizare sau în îmbunătățirea procesului de testare?

Răspuns scurt: Pornesc de la o problemă pe care managementul o recunoaște, o cuantific cu date din proiect (timp de regresie, incidente, întârzieri), propun un pilot mic, cu cost și rezultat măsurabil, și raportez rezultatele înainte de a cere extinderea.

Managementul nu cumpără „automatizare” sau „bune practici”. Cumpără rezultate: livrare mai rapidă, mai puține incidente, costuri mai mici, risc controlat. Răspunsul trebuie să arate că vorbești limba lor.

1. Pornesc de la o problemă recunoscută. De exemplu: release-urile se amână constant pentru că regresia manuală durează câteva zile, sau incidentele din producție consumă timpul developerilor.

2. Cuantific cu date reale din proiect, nu cu cifre generale din articole:

  • câte zile-om consumă regresia manuală pe release;
  • câte incidente au fost în ultimele luni și cât timp a costat rezolvarea lor;
  • cât de des s-a amânat un release din cauza testării.

3. Propun un pilot mic și concret. „În următoarele șase săptămâni automatizez smoke-ul și cele 5 fluxuri critice, cu rulare în CI la fiecare pull request. Costul: o parte din timpul meu și câteva ore de ajutor de la un developer pentru endpointurile de test.” Un pilot reduce riscul deciziei și e mult mai ușor de aprobat decât un proiect mare.

4. Spun clar și costurile și limitele. Automatizarea cere întreținere, nu prinde orice bug și nu elimină testarea manuală. Un pitch onest construiește încredere.

5. Raportez rezultatele. Durata regresiei înainte și după, bug-urile prinse de suita automată înainte de a ajunge în producție, feedbackul echipei. Cu aceste rezultate cer extinderea.

6. Găsesc aliați. Un lead de developeri sau un product owner care simte aceeași problemă face propunerea mult mai credibilă.

Un exemplu personal, chiar mic, în care ai convins pe cineva cu date, întărește mult răspunsul.

Ce urmărește intervievatorul: La nivel senior se verifică dacă știi să influențezi decizii de business. Greșeala tipică este argumentarea strict tehnică, fără legătură cu costuri și riscuri.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru QA Engineer (manual + automation)

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de QA Engineer (manual + automation), de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de QA Engineer (manual + automation)

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.