...
Pregătire interviuri

100 de întrebări de interviu Testare manuală, cu răspunsuri

Întrebările despre Testare manuală care apar des la interviurile tehnice, 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. Înveți de la zero cu Curs Testare manuală (QA): primele 12 lecții sunt gratuite.

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

  • 100întrebări
  • 52junior
  • 33mid
  • 15senior
  • 153 minde citit
Întrebări de interviu Testare manuală cu răspunsuri

La un interviu pentru un post de tester manual sau QA junior, întrebările vin de obicei în trei forme: teorie pe terminologia ISTQB Foundation (principii, niveluri, tipuri și tehnici de testare), exerciții practice în care ți se cere să testezi ceva pe loc („testează un câmp de login”, „testează un automat de cafea”, „ce valori alegi pentru acest interval”) și discuții despre cum lucrezi: cum scrii un raport de bug, cum colaborezi cu developerii, ce faci când nu ai cerințe. Uneori primești și o temă: o aplicație demo în care trebuie să găsești și să raportezi defecte într-un timp limitat.

La nivel de junior, intervievatorul vrea să vadă că folosești termenii corect, că știi să aplici clasele de echivalență și valorile limită fără să te încurci, că un caz de test sau un raport de bug scris de tine poate fi urmat de altcineva și că gândești și în afara „drumului fericit”. La nivel mid se adaugă planificarea, testarea bazată pe risc, criteriile de ieșire, lucrul în Scrum, testarea manuală a unui API cu Postman și deciziile pe care le iei când timpul nu ajunge.

Pagina este împărțită pe teme, iar în fiecare temă întrebările merg de la junior la senior. Citește întâi răspunsul scurt și încearcă să formulezi singur răspunsul complet, apoi compară cu explicația. La exercițiile practice, exersează cu voce tare: la interviu contează la fel de mult cum îți structurezi gândirea ca lista finală de teste.

Fundamente și principii

1 Junior

Care este diferența dintre eroare, defect și defecțiune? Dă un exemplu dintr-un magazin online.

Răspuns scurt: Eroarea este greșeala unui om (de exemplu, o cerință înțeleasă greșit), defectul este rezultatul ei în cod sau în documentație, iar defecțiunea (failure) este comportamentul greșit observat când rulezi aplicația.

Terminologia ISTQB separă trei momente ale aceleiași probleme. Eroarea (error, mistake) este o acțiune umană greșită: un analist scrie „reducerea se aplică la comenzi de peste 200 lei” când clientul voia „de la 200 lei”, sau un developer folosește > în loc de >=. Defectul (defect, bug, fault) este urma lăsată de eroare într-un produs de lucru: în cod, în cerință, în designul paginii. Defecțiunea (failure) apare abia când defectul este executat în anumite condiții și sistemul face altceva decât trebuie: clientul cu o comandă de exact 200 lei nu primește reducerea.

Distincția contează din trei motive:

  • Nu orice defect produce o defecțiune. Un defect într-o ramură de cod care nu rulează niciodată poate sta ascuns ani de zile.
  • O defecțiune poate avea și alte cauze decât un defect: condiții de mediu, configurare greșită, date corupte, o defecțiune hardware.
  • Testarea dinamică găsește defecțiuni, pe care apoi le investighezi ca să ajungi la defect. Recenziile (testarea statică) găsesc direct defecte în documente, fără să ruleze nimic.

În raportul de bug descrii defecțiunea pe care ai observat-o, cu pași și date. Găsirea defectului din cod și a cauzei lui rădăcină (de ce s-a greșit) este, de obicei, treaba developerului, cu ajutorul informațiilor tale.

Ce urmărește intervievatorul: Verifică dacă stăpânești vocabularul ISTQB și dacă înțelegi că testarea dinamică observă efecte, nu cauze. Mulți candidați folosesc cei trei termeni ca sinonime.

2 Junior

Care este diferența dintre testare și depanare (debugging)? Cine se ocupă de fiecare?

Răspuns scurt: Testarea găsește și documentează defecțiuni; depanarea caută cauza lor în cod, o repară și verifică reparația local. De obicei testerul testează, developerul depanează, apoi testerul retestează.

Cele două activități se succed, dar au obiective diferite. Testarea încearcă să facă aplicația să se comporte greșit și să arate că există o problemă: execuți cazuri de test, explorezi, compari rezultatul obținut cu cel așteptat, raportezi. Depanarea pornește de la o defecțiune deja cunoscută și răspunde la întrebarea „de ce se întâmplă?”: reproducerea problemei, localizarea defectului în cod (cu loguri, breakpoint-uri, analiză), corectarea lui și o verificare rapidă că reparația funcționează.

Fluxul tipic într-o echipă arată așa:

  • testerul găsește defecțiunea și scrie raportul, cu pași și dovezi;
  • developerul reproduce, depanează și repară;
  • testerul face retestarea (testarea de confirmare) pe build-ul nou;
  • se rulează teste de regresie în zona afectată, pentru că reparația poate strica altceva.

Linia nu este rigidă. La testele unitare, developerul testează și depanează singur. Un tester bun poate face o parte din investigație fără să intre în cod: restrânge pașii la minimum, verifică dacă problema apare pe mai multe browsere, se uită în consola browserului sau în tab-ul Network ca să vadă dacă răspunsul serverului e greșit. Asta scurtează mult depanarea, dar nu o înlocuiește.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi unde se termină rolul tău și cum predai o problemă mai departe. Greșeala tipică este să spui că testerul „repară bug-uri” sau că depanarea e tot testare.

3 Junior

Care sunt obiectivele testării? Dacă toate testele trec, înseamnă că aplicația nu are bug-uri?

Răspuns scurt: Testarea urmărește să găsească defecte, să reducă riscul, să verifice cerințele, să ofere informații pentru decizii și să construiască încredere. Testele trecute nu dovedesc lipsa bug-urilor, doar că nu le-ai găsit cu testele alese.

Obiectivele concrete depind de context, dar cele des întâlnite (și listate și în programa ISTQB) sunt:

  • evaluarea produselor de lucru: cerințe, user stories, design, cod;
  • găsirea defecțiunilor și a defectelor, cât mai devreme;
  • verificarea că cerințele specificate sunt îndeplinite și validarea că sistemul face ce are nevoie utilizatorul;
  • reducerea nivelului de risc al unei livrări;
  • furnizarea de informații pentru decizii, de exemplu dacă se lansează versiunea;
  • verificarea conformității cu standarde sau obligații legale (accesibilitate, protecția datelor).

La a doua parte a întrebării răspunsul este nu. Testarea poate arăta prezența defectelor, nu absența lor. Orice suită de teste acoperă o parte mică din combinațiile posibile de date, stări, browsere și ordini de pași. Dacă 300 de teste trec, ai aflat că în acele 300 de situații aplicația se comportă corect, iar riscul rămas este mai mic, dar nu zero.

Formularea corectă la sfârșitul unui ciclu de testare nu este „nu mai sunt bug-uri”, ci ceva de genul: „am acoperit cerințele X și Y, riscurile mari au fost testate, rămân trei defecte minore cunoscute, iar zona Z nu a fost testată din lipsă de timp”.

Ce urmărește intervievatorul: Verifică maturitatea: un tester care promite „zero bug-uri” va pierde credibilitatea la primul incident. Intervievatorul caută și ideea că testarea produce informație pentru decizii, nu doar liste de bug-uri.

4 Junior

Ce este paradoxul pesticidului? Ce faci concret ca să nu ți se întâmple cu suita de regresie?

Răspuns scurt: Dacă repeți aceleași teste la nesfârșit, ele încetează să mai găsească defecte noi, la fel cum insectele devin rezistente la un pesticid. Remediul: revizuiești, modifici și completezi periodic testele și datele lor.

În programa ISTQB 4.0, principiul apare sub numele „testele se uzează” (tests wear out). Primele rulări ale unei suite găsesc multe probleme, developerii le repară, iar codul se „adaptează” la acele teste. După câteva sprinturi, aceleași pași cu aceleași date trec mereu, deși în aplicație au apărut zone noi și riscuri noi pe care suita nu le atinge.

Ce poți face practic:

  • variezi datele de test: alte nume, alte sume, alte produse, caractere speciale, conturi cu istoric diferit;
  • adaugi cazuri pentru defectele găsite recent și pentru zonele modificate în ultimele livrări;
  • elimini sau comasezi testele care nu au mai găsit nimic de mult timp și verifică lucruri deja acoperite în altă parte;
  • alternezi testarea scriptată cu sesiuni scurte de testare exploratorie pe aceeași funcționalitate;
  • schimbi ordinea pașilor sau combinațiile (alt browser, alt dispozitiv, alt rol de utilizator);
  • revizuiești suita împreună cu un coleg care nu a scris-o, ca să vezi ce lipsește.

Atenție, paradoxul are și o parte bună: în regresia automată vrei uneori exact aceleași teste, ca să detectezi stricăciuni ale comportamentului vechi. Problema apare doar când te bazezi pe ele ca să găsești defecte noi.

Ce urmărește intervievatorul: Intervievatorul vrea acțiuni concrete, nu recitarea principiului. Greșeala tipică este să spui doar „schimbăm testele” fără să explici cum și cât de des.

5 Junior

Ce înseamnă principiul „absența erorilor este o iluzie”? Dă un exemplu în care aplicația trece toate testele, dar e totuși un eșec.

Răspuns scurt: Un sistem fără defecte cunoscute poate fi inutil dacă nu rezolvă problema utilizatorilor sau e greu de folosit. Verificarea față de specificație nu garantează validarea față de nevoile reale.

Principiul (absence-of-defects fallacy) spune că a găsi și a repara multe defecte nu asigură succesul unui produs. Poți avea o aplicație care respectă literal fiecare cerință scrisă și în care toate cazurile de test trec, dar care:

  • implementează cerințe greșite sau incomplete;
  • este prea lentă sau prea complicată pentru utilizatorii reali;
  • e inferioară variantei pe care oamenii o foloseau deja.

Exemplu: o firmă de curierat cere o aplicație mobilă în care curierul confirmă livrarea. Specificația spune „confirmarea se face după completarea a 8 câmpuri”. Echipa implementează exact asta, testele trec, nu există bug-uri deschise. În teren, curierii au mâinile ocupate, livrează 80 de colete pe zi și nu completează 8 câmpuri la fiecare. Aplicația nu e folosită, iar confirmările se fac tot pe hârtie.

Ca tester, poți reduce riscul ăsta prin:

  • recenzia cerințelor cu întrebări de tip „cine folosește asta, unde, cât de des?”;
  • testare de utilizabilitate și testare de acceptanță cu utilizatori reali, nu doar cu echipa;
  • semnalarea problemelor de experiență chiar dacă nu încalcă nicio cerință scrisă, ca observații sau sugestii.

Aici intră diferența dintre a construi produsul corect (validare) și a construi produsul în mod corect (verificare).

Ce urmărește intervievatorul: Verifică dacă înțelegi că rolul testerului nu se limitează la a bifa cerințe. Mulți candidați recită numele principiului, dar nu pot da un exemplu credibil.

6 Junior

Ce este testware-ul? Ce documente și artefacte produce un tester pe parcursul unui proiect?

Răspuns scurt: Testware-ul este tot ce produce testarea și se poate refolosi: plan de testare, condiții și cazuri de test, date de test, checklisturi, scripturi, rapoarte de defect, rapoarte de progres și de finalizare.

Termenul acoperă produsele de lucru create în fiecare activitate a procesului de testare. Pe etape, arată cam așa:

  • planificare: planul de testare, calendarul, registrul de riscuri, criteriile de intrare și de ieșire;
  • analiză: condițiile de test (ce trebuie testat), prioritizate, plus defectele găsite în cerințe;
  • proiectare: cazuri de test, date de test, cerințele pentru mediu, charter-uri pentru testare exploratorie;
  • implementare: proceduri și suite de teste, datele pregătite efectiv în baza de date, scripturi automate, calendarul de execuție;
  • execuție: jurnale de execuție, statusuri (Pass, Fail, Blocked), capturi, rapoarte de defect;
  • monitorizare și control: rapoarte de progres;
  • finalizare: raportul de finalizare, lecțiile învățate, testware-ul arhivat sau predat echipei de mentenanță.

De ce contează la interviu: testware-ul este ceea ce rămâne după tine. Dacă pleci din proiect sau vine un tester nou, el trebuie să poată relua munca din cazurile, datele și rapoartele tale. De aici și ideea de a păstra testware-ul legat de cerințe (trasabilitate) și versionat, de exemplu în TestRail sau într-un repository.

Într-o echipă Agile, multe dintre acestea sunt mai ușoare: criteriile de acceptare țin loc de condiții de test, iar planul poate fi o pagină în Confluence. Ele există totuși, chiar dacă nu se numesc la fel.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi testarea ca proces cu ieșiri concrete, nu doar ca „dau click-uri”. Greșeala tipică este să enumeri doar cazurile de test și rapoartele de bug.

7 Junior

Ce este un oracol de test? De unde știi care este rezultatul așteptat atunci când nu ai o specificație completă?

Răspuns scurt: Oracolul de test este sursa din care afli rezultatul așteptat: cerințe, criterii de acceptare, un sistem vechi, un calcul independent, standarde sau un expert de domeniu. Fără oracol nu poți decide dacă testul a trecut.

Orice test are două părți: ce faci și cum hotărăști dacă ce vezi e corect. A doua parte este oracolul. Cel mai simplu oracol este o cerință clară: „la parolă greșită apare mesajul X”. Foarte des însă specificația tace, iar testerul trebuie să găsească alte surse:

  • criteriile de acceptare ale story-ului și discuțiile din tichetul Jira;
  • un sistem vechi sau un produs similar (o aplicație înlocuită, versiunea anterioară);
  • un calcul făcut independent, de exemplu rata unui credit calculată în Excel;
  • standarde și reguli externe: legislație fiscală, WCAG pentru accesibilitate, formatul IBAN;
  • consistența internă: același preț trebuie să apară identic în listă, în coș și pe factură;
  • expectativele rezonabile ale utilizatorului și convențiile platformei;
  • un expert de domeniu sau Product Owner-ul.

Când nu există un oracol sigur, nu inventa rezultatul așteptat. Notezi ce ai observat, spui pe ce te bazezi („versiunea 2.3 rotunjea la două zecimale, acum la una”) și ceri clarificare. Un raport de forma „nu sunt sigur dacă e bug, comportamentul diferă de X” este legitim.

Problema oracolului apare mai ales la sisteme cu calcule complexe sau rezultate nedeterministe (căutare, recomandări, răspunsuri generate de AI), unde verifici proprietăți („rezultatele conțin termenul căutat”, „suma totală nu e negativă”) în loc de o valoare exactă.

Ce urmărește intervievatorul: Verifică dacă știi ce faci când specificația lipsește, situație foarte frecventă. Greșeala tipică este să decizi singur rezultatul așteptat fără să spui pe ce te bazezi.

Greșeala, în practică:Caz de test fără rezultat așteptatRezultat așteptat din presupuneri

8 Junior

Citește cerința de mai jos și spune ce probleme găsești la recenzie, înainte să se scrie vreo linie de cod.

US-12: Ca utilizator, vreau să mă pot înregistra rapid.
- Parola trebuie să fie sigură.
- Emailul trebuie să fie valid.
- După înregistrare, utilizatorul primește un email de confirmare în scurt timp.
- Vârsta minimă este 18 ani.

Răspuns scurt: Cerința e vagă și netestabilă: „rapid”, „sigură”, „valid” și „în scurt timp” nu au criterii măsurabile, lipsesc mesajele de eroare, comportamentul la email deja folosit și modul în care se verifică vârsta.

Recenzia cerințelor este testare statică: găsești defecte în document, unde costă cel mai puțin să fie reparate. Pe textul de mai sus aș ridica, în ordine:

  • „rapid”: ce înseamnă? Număr maxim de câmpuri, timp de completare, înregistrare cu Google? Altfel nu se poate testa.
  • „parola sigură”: lungime minimă și maximă, ce tipuri de caractere sunt obligatorii, sunt permise spațiile și diacriticele, se verifică față de liste de parole compromise?
  • „email valid”: doar format sau și existența domeniului? Ce se întâmplă dacă emailul există deja în sistem? Se face diferența între majuscule și minuscule?
  • „în scurt timp”: e nevoie de o valoare (de exemplu, sub 5 minute) și de comportamentul când emailul nu ajunge: se poate retrimite?
  • vârsta: se cere data nașterii sau o bifă „am peste 18 ani”? Ce mesaj primește un minor?
  • ce stare are contul până la confirmare: se poate loga sau nu? Cât timp e valabil linkul?
  • lipsesc mesajele de eroare, câmpurile obligatorii, acordul GDPR și termenii.

Fiecare observație o formulez ca întrebare sau propunere concretă, nu ca reproș: „propun: parola are 8–64 de caractere, cel puțin o literă și o cifră”. Rezultatul recenziei sunt criterii de acceptare clare, din care apoi pot deriva direct clase de echivalență și valori limită.

Ce urmărește intervievatorul: Exercițiul verifică dacă știi să faci shift-left concret și dacă recunoști termenii netestabili. Candidații slabi spun doar „cerința e bună” sau sar direct la cazuri de test.

Greșeala, în practică:Cerință ambiguă testată fără clarificare

9 Mid

Ce tipuri de recenzii cunoști? Prin ce diferă o recenzie informală de un walkthrough, de o recenzie tehnică și de o inspecție?

Răspuns scurt: Diferă prin grad de formalizare: recenzia informală nu are proces, walkthrough-ul e condus de autor, recenzia tehnică e făcută de experți ca să ia decizii, iar inspecția are roluri, pregătire, metrici și urmărirea defectelor.

Programa ISTQB descrie patru tipuri, de la cel mai puțin la cel mai formal:

  • Recenzia informală: un coleg citește documentul și îți lasă comentarii, fără proces definit și fără raport. Exemplu: un comentariu pe pull request sau pe pagina din Confluence. E rapidă și ieftină, dar depinde mult de cine o face.
  • Walkthrough: autorul prezintă documentul unui grup și îl parcurge pas cu pas. Scopuri: găsirea defectelor, dar și înțelegerea comună, instruirea colegilor, obținerea de idei. Pregătirea dinainte poate lipsi.
  • Recenzia tehnică: un grup de experți (arhitecți, developeri seniori, testeri) evaluează un document tehnic, de exemplu designul unei integrări, ca să ajungă la consens și să ia decizii. Are un moderator și, de obicei, pregătire individuală.
  • Inspecția: cea mai formală. Roluri clare (autor, moderator, scrib, recenzenți), pregătire individuală obligatorie, checklisturi, criterii de intrare și de ieșire, metrici colectate și urmărirea corectării fiecărui defect. Se folosește pentru documente critice, de exemplu în domenii reglementate.

Indiferent de tip, recenzia are aceleași etape generale: planificare, inițiere, recenzie individuală, discutarea problemelor, corectare și raportare.

În practică, un tester participă cel mai des la recenzii informale ale story-urilor în refinement și la walkthrough-uri ale designului. Factorii de succes contează: obiective clare, timp suficient de pregătire, focus pe document, nu pe autor.

Ce urmărește intervievatorul: Întrebarea vine des la interviurile care cer ISTQB. Greșeala tipică este confuzia dintre walkthrough și inspecție sau ideea că recenzia e o ședință în care se critică autorul.

10 Mid

Explică legătura dintre baza de testare (test basis), condițiile de test, cazurile de test și procedurile de test. Prin ce diferă analiza de proiectarea testelor?

Răspuns scurt: Din baza de testare (cerințe, story-uri, design) extragi în analiză condițiile de test, adică „ce” testezi. În proiectare transformi condițiile în cazuri de test cu date și rezultate așteptate („cum”), iar procedura ordonează cazurile pentru execuție.

Lanțul arată așa:

  • Baza de testare: orice sursă din care afli cum trebuie să se comporte sistemul: cerințe, user stories, criterii de acceptare, machete Figma, specificația unui API, chiar și un sistem vechi.
  • Condiția de test: un aspect testabil, formulat la nivel înalt. Exemplu: „reducerea de fidelitate se aplică doar clienților cu card activ”.
  • Cazul de test: precondiții, pași, date concrete și rezultatul așteptat. Exemplu: „client cu card activ, coș de 250 lei, aplică reducerea → total 225 lei”.
  • Procedura de test: ordinea în care rulezi mai multe cazuri, cu pașii de pregătire și de curățare. Mai multe proceduri formează o suită.

Analiza testelor răspunde la „ce testăm?”: citești baza, găsești defecte în ea (ambiguități, contradicții), identifici și prioritizezi condițiile. Proiectarea răspunde la „cum testăm?”: aplici tehnici (clase de echivalență, valori limită, tabele de decizie), alegi datele, stabilești mediul necesar.

De ce contează separarea: dacă sari direct la cazuri de test, riști să scrii 40 de cazuri pentru o condiție ușoară și niciunul pentru una riscantă. Condițiile îți dau o listă scurtă pe care o poți revizui cu Product Owner-ul înainte de a investi timp în detalii, iar trasabilitatea cerință → condiție → caz arată clar ce acoperi. În echipele Agile, condițiile se suprapun adesea cu criteriile de acceptare.

Ce urmărește intervievatorul: Verifică dacă înțelegi procesul de testare, nu doar execuția. Candidații confundă des condiția de test cu cazul de test sau nu pot spune la ce folosește nivelul intermediar.

Greșeala, în practică:Cerințe fără niciun caz de testCaz de test fără cerință asociată

11 Senior

Ce înseamnă independența testării? Care sunt avantajele și dezavantajele unei echipe de test complet separate de dezvoltare?

Răspuns scurt: Independența înseamnă cât de departe e testerul de autorul codului: de la autorul însuși, la un coleg, un tester din echipă, o echipă de test separată sau o firmă externă. Mai multă independență aduce alt punct de vedere, dar și izolare și întârzieri.

Programa ISTQB descrie o scară: autorul își testează propriul cod; un alt developer din echipă; testeri integrați în echipa de produs; o echipă de test separată în aceeași organizație; testeri externi (alt departament, alt furnizor, un auditor).

Avantajele independenței:

  • testerul are alte presupuneri decât autorul, deci vede alte probleme; autorul tinde să testeze ce a vrut să facă, nu ce a făcut;
  • poate contesta presupunerile din cerințe și design;
  • poate raporta mai liber, fără presiunea de a-și apăra munca.

Dezavantajele:

  • izolare: testerii află târziu de schimbări și primesc informații incomplete;
  • comunicarea se transformă în aruncat tichete peste zid, cu relații tensionate;
  • developerii pot pierde sentimentul responsabilității pentru calitate („testează QA”);
  • echipa de test devine un blocaj la final și e învinovățită pentru întârzieri.

Echilibrul folosit des acum: testeri integrați în echipa Scrum, care lucrează zilnic cu developerii (independență medie), developeri care își scriu testele unitare, plus testări independente punctuale acolo unde riscul o cere: un audit de securitate extern, testare de acceptanță cu clientul, un test de penetrare făcut de altă firmă. Ca senior, alegi nivelul de independență în funcție de risc și context, nu din principiu.

Ce urmărește intervievatorul: Verifică dacă vezi compromisurile organizaționale ale testării. Răspunsul slab este „cu cât mai independent, cu atât mai bine”, fără costurile acestei alegeri.

Niveluri și tipuri de testare

12 Junior

Ce este testarea de integrare? Explică abordarea big-bang față de cea incrementală și rolul unui stub și al unui driver.

Răspuns scurt: Testarea de integrare verifică interfețele și interacțiunea dintre componente sau sisteme. Big-bang le leagă pe toate deodată; incremental (top-down, bottom-up) le adaugi pe rând, folosind stub-uri pentru piesele de jos lipsă și drivere pentru cele de sus.

ISTQB separă integrarea componentelor (module din aceeași aplicație, de exemplu serviciul de coș și cel de prețuri) de integrarea sistemelor (aplicația ta cu un procesator de plăți, cu un ERP, cu un serviciu de curierat). În ambele cazuri nu mai verifici logica internă a unei piese, ci dacă piesele vorbesc corect între ele: formatul datelor, codurile de eroare, timeout-urile, ordinea apelurilor.

Big-bang: integrezi toate componentele odată și testezi ansamblul. E simplu de organizat, dar când ceva pică e greu de găsit unde, iar testarea începe târziu.

Incremental: adaugi componentele una câte una.

  • top-down: pornești de la nivelul de sus (interfața, orchestratorul) și înlocuiești componentele de dedesubt care încă nu există cu stub-uri, adică înlocuitori simpli care întorc răspunsuri fixe. Exemplu: un stub pentru serviciul de livrare care întoarce mereu „15 lei”.
  • bottom-up: pornești de la componentele de jos și le apelezi cu drivere, adică bucăți de cod sau unelte care joacă rolul apelantului. Postman poate fi, practic, un driver pentru un API fără interfață.

Ca tester manual, ce faci concret la integrare: verifici că o comandă plasată în magazin apare corect în sistemul de facturare, că un răspuns de eroare de la plăți e tradus într-un mesaj ușor de înțeles, ce se întâmplă când serviciul extern nu răspunde. Sunt locuri unde apar multe defecte, pentru că fiecare echipă a presupus altceva despre cealaltă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce caută testarea de integrare și dacă înțelegi termenii stub și driver. Greșeala tipică este să descrii integrarea ca „testarea întregii aplicații”.

13 Junior

Ce tipuri de testare de acceptanță cunoști? Cine face UAT, testarea de acceptanță operațională, testarea alfa și testarea beta?

Răspuns scurt: UAT o fac utilizatorii sau reprezentanții lor, ca să confirme că sistemul le servește nevoile. Cea operațională o fac echipele de operare (backup, recuperare, monitorizare). Alfa are loc la producător, beta la utilizatori, în mediul lor real.

Testarea de acceptanță răspunde la întrebarea „putem lua în folosință sistemul?”. Ea nu urmărește în primul rând să găsească defecte, ci să construiască încredere și să confirme că produsul e gata. Tipurile descrise de ISTQB:

  • UAT (User Acceptance Testing): utilizatorii finali sau reprezentanții lor verifică fluxurile din munca lor reală. Exemplu: contabilii unei firme rulează închiderea de lună în noul ERP.
  • Testarea de acceptanță operațională (OAT): administratorii de sistem și echipa de operare verifică backup și restaurare, instalare și dezinstalare, recuperare după dezastru, gestionarea utilizatorilor, monitorizare și alertare, proceduri de mentenanță.
  • Testarea de acceptanță contractuală și de reglementare: verifici criteriile dintr-un contract cu un furnizor sau cerințe legale (de exemplu, accesibilitate obligatorie, păstrarea datelor). Rezultatele pot fi auditate.
  • Testarea alfa: utilizatori sau testeri independenți încearcă produsul în mediul producătorului, înainte de lansare.
  • Testarea beta: utilizatori reali folosesc produsul în mediul lor (dispozitivele, rețeaua și datele lor) și trimit feedback. Exemplu: canalul de testare închisă din Google Play sau TestFlight pe iOS.

Ca tester, la UAT de obicei nu execuți tu testele, ci pregătești mediul și datele, scrii scenariile pe limbajul utilizatorilor, ajuți la raportarea problemelor și separi defectele reale de cererile noi de funcționalitate, care apar inevitabil.

Ce urmărește intervievatorul: Verifică dacă știi că acceptanța are mai multe forme și cine o face. Mulți candidați reduc totul la UAT și cred că testerul QA execută singur testarea de acceptanță.

14 Junior

Construiește un smoke test pentru un magazin online pe care îl rulezi în 10–15 minute după fiecare deploy. Ce include și ce lași deliberat afară?

Răspuns scurt: Include fluxurile critice, câte un drum fericit: pagina se încarcă, login, căutare, pagina de produs, adăugare în coș, checkout până la plată (pe test), contul clientului. Lași afară validările detaliate, cazurile negative și zonele cu risc mic.

Smoke testul răspunde la o singură întrebare: e build-ul suficient de stabil ca să merite testat mai departe (sau, după un deploy în producție, e site-ul funcțional)? De aceea e scurt, larg și superficial. Un checklist realist:

  • pagina principală se încarcă fără erori în consolă și cu imaginile vizibile;
  • înregistrare cont nou și login cu un cont existent;
  • căutarea întoarce rezultate pentru un produs cunoscut;
  • filtrul și sortarea pe o categorie funcționează;
  • pagina unui produs afișează preț, stoc, buton de adăugare;
  • adăugare în coș, modificare cantitate, totalul se recalculează;
  • checkout cu adresă și metodă de livrare, plată cu un card de test (sau până la pasul de plată în producție);
  • comanda apare în „Comenzile mele”, iar emailul de confirmare pleacă;
  • logout.

Ce las afară: valorile limită pe câmpuri, toate metodele de plată, toate browserele, texte, cazuri negative, rapoarte din administrare. Acestea sunt pentru testarea funcțională și de regresie.

Reguli practice: checklistul are un responsabil și se actualizează când apare un flux critic nou; pașii sunt scriși clar, ca să-i poată rula oricine; dacă un singur punct pică, build-ul e respins sau se ia decizia de rollback, fără să continui testarea detaliată. Smoke testul e primul candidat la automatizare, tocmai pentru că se repetă după fiecare deploy.

Ce urmărește intervievatorul: Verifică dacă înțelegi scopul smoke testului prin construirea unuia concret. Greșeala tipică este o listă de 60 de verificări care nu mai e „smoke”, ci o regresie completă.

Greșeala, în practică:Testare fără smoke test

15 Junior

Ce este testarea de compatibilitate? Cum alegi pe ce browsere, sisteme de operare și dispozitive testezi, când nu poți acoperi toate combinațiile?

Răspuns scurt: Verifici că aplicația funcționează corect în medii diferite: browsere, versiuni, sisteme de operare, dispozitive, rezoluții. Alegi combinațiile după datele de analytics ale produsului, publicul țintă, cerințele contractuale și riscurile cunoscute ale fiecărei platforme.

Combinațiile posibile sunt practic nelimitate, așa că alegerea se face pe bază de date și risc, nu de gust. Pașii pe care i-aș urma:

  • iau din Google Analytics (sau din ce folosește produsul) distribuția reală a browserelor, sistemelor și rezoluțiilor vizitatorilor;
  • verific dacă există o listă de browsere suportate în contract sau în documentația produsului;
  • împart combinațiile pe niveluri: nivelul 1 (cele mai folosite, de exemplu Chrome desktop, Safari pe iPhone, Chrome pe Android) primește testare completă; nivelul 2 primește smoke și fluxurile critice; restul primesc doar o verificare ocazională;
  • adaug combinațiile cu risc cunoscut, chiar dacă au puțini utilizatori: Safari are comportamente proprii la câmpurile de dată, la cookie-uri și la unele proprietăți CSS; Firefox folosește alt motor de randare decât Chrome și Edge, care împart același motor;
  • urmăresc și ecranele foarte mici și foarte mari, zoom-ul de 200%, modul întunecat al sistemului.

Ce verifici concret: aspectul paginii (elemente suprapuse, texte tăiate), funcționalitatea controalelor (date picker, upload, drag and drop), fonturi, video, notificări, comportamentul la autocompletare și la butonul Înapoi.

Pentru acoperire largă fără multe dispozitive fizice se folosesc emulatoarele din DevTools și servicii cloud precum BrowserStack sau Sauce Labs. Lista de combinații se revizuiește periodic, pentru că utilizatorii își schimbă browserele.

Ce urmărește intervievatorul: Intervievatorul vrea un criteriu de alegere, nu „testez pe toate”. Greșeala tipică este să uiți de Safari sau să presupui că, dacă merge în Chrome, merge peste tot.

Greșeala, în practică:Testat doar pe desktopTestat într-un singur browser

16 Junior

Ce este testarea de utilizabilitate? Ce verifici concret și cum raportezi o problemă de utilizabilitate care nu încalcă nicio cerință?

Răspuns scurt: Utilizabilitatea măsoară cât de ușor, eficient și plăcut își ating utilizatorii scopul. Verifici claritatea pașilor, mesajele de eroare, consistența, feedbackul vizual, numărul de pași. Raportezi ca observație sau îmbunătățire, cu impactul descris din perspectiva utilizatorului.

Utilizabilitatea (usability) e o caracteristică nefuncțională: aplicația poate face corect tot ce trebuie, dar oamenii să nu reușească să o folosească. Ca tester manual, verifici de obicei:

  • claritatea: utilizatorul știe ce să facă pe fiecare ecran? Butoanele principale sunt evidente?
  • mesajele de eroare: spun ce e greșit și cum se repară („Parola trebuie să aibă minimum 8 caractere”), nu doar „Eroare”; apar lângă câmpul greșit; nu șterg datele deja completate;
  • consistența: aceleași denumiri și aceleași poziții ale butoanelor în toată aplicația;
  • feedbackul: după un click se vede că se întâmplă ceva (indicator de încărcare, butonul devine inactiv);
  • efortul: număr de pași și de câmpuri, valori implicite rezonabile, tastatura potrivită pe mobil pentru email și telefon;
  • prevenirea și recuperarea erorilor: confirmare la ștergere, posibilitatea de anulare.

O referință utilă sunt cele 10 euristici de utilizabilitate ale lui Jakob Nielsen.

Când problema nu încalcă nicio cerință, nu o declari bug critic. O raportezi ca îmbunătățire sau observație, descriind situația concretă: „Pe mobil, butonul «Plătește» e sub tastatură; utilizatorul trebuie să o închidă ca să-l vadă”. Decizia aparține Product Owner-ului. Testarea de utilizabilitate propriu-zisă, cu utilizatori reali observați în timp ce rezolvă sarcini, o organizează de obicei designerii UX, dar testerul poate contribui cu observațiile adunate.

Ce urmărește intervievatorul: Verifică dacă gândești ca un utilizator, nu doar ca un verificator de cerințe. Greșeala tipică este să consideri că utilizabilitatea înseamnă doar „arată frumos”.

17 Mid

Ce caracteristici de calitate definește standardul ISO/IEC 25010 și cum le folosești ca listă de verificare pentru testarea nefuncțională?

Răspuns scurt: Versiunea din 2011 definește opt caracteristici: adecvare funcțională, eficiența performanței, compatibilitate, utilizabilitate, fiabilitate, securitate, mentenabilitate și portabilitate. Le parcurgi pe rând și decizi, pentru fiecare, ce risc există și ce testezi.

ISO/IEC 25010 este standardul la care face trimitere programa ISTQB când vorbește de testare nefuncțională. În versiunea din 2011, cea mai citată, modelul are opt caracteristici, fiecare cu subcaracteristici:

  • adecvare funcțională: completitudine, corectitudine, potrivire cu scopul;
  • eficiența performanței: timp de răspuns, consum de resurse, capacitate;
  • compatibilitate: coexistență cu alte aplicații, interoperabilitate;
  • utilizabilitate: ușurința învățării, protecția față de erorile utilizatorului, accesibilitate;
  • fiabilitate: maturitate, disponibilitate, toleranță la erori, recuperare;
  • securitate: confidențialitate, integritate, nerepudiere, autenticitate, trasabilitate a acțiunilor;
  • mentenabilitate: modularitate, ușurința modificării și a testării;
  • portabilitate: adaptabilitate, instalare, înlocuire.

Revizuirea din 2023 a modificat modelul: a adăugat siguranța (safety), a redenumit unele caracteristici (de exemplu, utilizabilitatea devine „capacitate de interacțiune”, portabilitatea devine „flexibilitate”). La interviu e suficient să știi varianta din 2011 și că există o revizuire.

Cum îl folosesc practic: la începutul planificării iau lista și, împreună cu echipa, notez pentru fiecare caracteristică dacă e relevantă și ce risc are. Pentru un magazin online de Black Friday, performanța e critică; pentru o aplicație bancară, securitatea și fiabilitatea; pentru o aplicație publică, accesibilitatea poate fi și obligație legală. Lista mă ajută să nu reduc testarea nefuncțională la „merge repede?”.

Ce urmărește intervievatorul: Verifică dacă ai o structură pentru testarea nefuncțională. Candidații de nivel mid știu de obicei doar performanța și securitatea și uită de fiabilitate sau portabilitate.

18 Mid

Ce sunt internaționalizarea și localizarea? Ce verifici într-o aplicație care se lansează în română, engleză și germană?

Răspuns scurt: Internaționalizarea (i18n) înseamnă că aplicația e construită să suporte mai multe limbi și formate; localizarea (l10n) e adaptarea pentru o anumită piață: traduceri, formate de dată și număr, monedă, reguli legale. Verifici ambele.

Internaționalizarea ține de cod: textele nu sunt scrise direct în cod, ci în fișiere de traduceri, iar formatele se iau din setările de limbă și regiune. Localizarea ține de conținut: traducerea efectivă și adaptarea la o piață. Ce verific concret:

  • traduceri complete: niciun text rămas în limba sursă, nicio cheie tehnică afișată (de exemplu checkout.button.pay), mesaje de eroare și emailuri traduse;
  • lungimea textelor: germana are cuvinte lungi, care pot ieși din butoane sau pot fi tăiate în meniuri;
  • diacriticele: ă, â, î, ș, ț afișate corect peste tot, inclusiv în PDF-uri, emailuri, SMS-uri și la căutare („Brașov” găsit și când cauți „Brasov”, dacă așa s-a decis); variantele vechi ale lui ș și ț, cu sedilă în loc de virgulă, ar trebui tratate ca echivalente la căutare;
  • formate: dată (31.10.2026 în România, 10/31/2026 în SUA), separatorul zecimal (1.234,56 în română și germană, 1,234.56 în engleză), monedă și poziția ei, unități de măsură, format de telefon și cod poștal;
  • sortarea alfabetică: unde apar cuvintele cu diacritice în listă;
  • pluralul: „1 produs”, „2 produse”, „20 de produse” au forme diferite în română;
  • conținut legal și cultural: TVA, termeni, imagini potrivite, sărbători;
  • schimbarea limbii din interfață păstrează pagina și coșul.

Dacă aplicația va suporta limbi scrise de la dreapta la stânga, cum e araba, se adaugă testarea oglindirii interfeței.

Ce urmărește intervievatorul: Verifică dacă te gândești dincolo de traducerea textului. Greșeala tipică este să uiți de formatele numerice și de lungimea textelor, care produc cele mai multe defecte vizibile.

19 Mid

Ce poate verifica un tester manual la securitate, fără unelte specializate de penetrare? Dă exemple de teste concrete.

Răspuns scurt: Destul de multe: accesul la datele altui utilizator schimbând un ID în URL, accesul la pagini fără login, sesiunea după logout, mesaje de eroare care expun detalii tehnice, date sensibile în URL, limitarea încercărilor de login și caractere speciale în câmpuri.

Testarea de securitate completă e o specializare, dar multe probleme din lista OWASP Top 10 se pot observa cu browserul și cu Postman. Testele le fac doar pe mediile de test și cu acordul echipei:

  • control de acces: logat ca utilizatorul A, deschid /comenzi/1042, apoi schimb în /comenzi/1043, o comandă a utilizatorului B. Dacă o văd, e un defect grav (IDOR, Insecure Direct Object Reference). La fel, ca utilizator obișnuit, încerc URL-urile din administrare.
  • autentificare: după logout, butonul Înapoi sau un link salvat nu trebuie să redea datele; sesiunea expiră după inactivitate; după schimbarea parolei, celelalte sesiuni sunt închise (dacă așa e cerința); login-ul se blochează sau cere verificare suplimentară după multe încercări greșite; mesajul nu spune dacă emailul există.
  • date expuse: parole, tokenuri sau CNP în URL, în răspunsurile API mai mult decât arată interfața, în mesajele de eroare (stack trace, versiuni de server).
  • input: introduc <b>test</b> sau <script>alert(1)</script> într-un câmp de nume; dacă textul afișat apare îngroșat sau rulează scriptul, e posibil XSS. Un apostrof în câmpuri poate scoate la iveală erori de SQL.
  • validarea doar în frontend: trimit direct din Postman valori pe care interfața le blochează.
  • HTTPS peste tot și cookie-uri de sesiune cu Secure și HttpOnly, vizibile în DevTools.

Ce găsesc raportez ca defect de severitate mare, fără detalii publice, iar pentru teste de penetrare reale recomand specialiști.

Ce urmărește intervievatorul: Verifică dacă știi că securitatea nu e doar treaba altora și dacă ai idei concrete. Greșeala tipică este să spui „nu fac securitate, nu am unelte”.

Greșeala, în practică:Acces direct prin URL netestat

20 Mid

Cum evaluezi performanța unei aplicații web ca tester manual, fără JMeter sau k6? Ce poți observa și ce nu poți?

Răspuns scurt: Poți măsura timpii unei singure sesiuni cu tab-ul Network și Lighthouse, simula rețea lentă, observa comportamentul cu volume mari de date și dublu click. Nu poți simula sute de utilizatori simultan: pentru încărcare ai nevoie de unelte dedicate.

Testarea de încărcare (mulți utilizatori simultan) cere unelte, dar performanța percepută de un utilizator se poate evalua manual și prinde multe probleme:

  • tab-ul Network din DevTools: timpul total de încărcare, cel mai lent request, timpul până la primul byte (TTFB) al răspunsului serverului, dimensiunea paginii, imagini de câțiva MB unde ar ajunge câteva sute de KB, request-uri duplicate sau apeluri repetate la fiecare tastă apăsată;
  • throttling: setezi rețeaua pe „Slow 4G” sau „3G” și procesorul încetinit; vezi dacă aplicația afișează indicator de încărcare, dacă butoanele rămân clicabile de două ori, dacă apar timeout-uri;
  • Lighthouse (în Chrome DevTools) și PageSpeed Insights: raport cu metricile Core Web Vitals (LCP, CLS, INP) și recomandări;
  • volume mari de date: un cont cu 2.000 de comenzi, o listă fără paginare, un coș cu 100 de produse, un fișier încărcat aproape de limita permisă, căutări care întorc mii de rezultate;
  • sesiuni lungi: aplicația ținută deschisă o oră; dacă devine tot mai lentă, poate exista o scurgere de memorie (se vede în tab-ul Memory sau în Task Manager-ul browserului).

Ce nu poți afla manual: comportamentul la 500 de utilizatori simultan, punctul în care serverul cedează, stabilitatea la încărcare de ore. Pentru asta propui teste cu k6, JMeter sau Gatling. Raportezi observațiile cu cifrele măsurate, browserul și setările de rețea, nu doar „e lent”.

Ce urmărește intervievatorul: Verifică dacă știi limitele testării manuale, dar și ce poți totuși face. Răspunsul slab e un „e treaba celor de performanță” sau un raport de tip „merge greu”.

21 Senior

Ce este testarea de mentenanță și analiza de impact? Echipa face un hotfix la calculul TVA cu o zi înainte de lansare. Ce testezi?

Răspuns scurt: Testarea de mentenanță se face pe un sistem deja în producție, după modificări, migrări sau retrageri de funcționalități. Analiza de impact stabilește ce zone pot fi afectate de schimbare. Pentru hotfix testezi reparația, apoi toate locurile unde apare TVA-ul.

Testarea de mentenanță are trei declanșatori clasici: modificări (corecții, funcționalități noi, schimbări de configurare), migrări (alt server, altă bază de date, altă versiune de platformă) și retrageri (o funcție scoasă, date arhivate care trebuie să rămână accesibile). Diferența față de testarea unui sistem nou este că ai deja utilizatori și date reale, deci regresia contează enorm.

Analiza de impact se face înainte de testare: împreună cu developerul afli ce fișiere și module s-au schimbat, cine le folosește, ce date sunt atinse. Instrumentele utile sunt trasabilitatea (ce cerințe și teste țin de acea zonă), istoricul defectelor și diff-ul de cod.

Pentru hotfixul la TVA, înainte de lansare, aș face:

  • retestarea exactă a defectului reparat, cu datele din raport;
  • identificarea tuturor locurilor unde apare TVA-ul: coș, checkout, confirmare de comandă, factură PDF, emailuri, panoul de administrare, exporturi contabile, retururi și rambursări;
  • teste pe valori limită și pe cote diferite, dacă există mai multe (de exemplu, produse cu cotă redusă), plus rotunjiri cu bani;
  • verificarea comenzilor vechi: o factură emisă ieri nu trebuie să-și schimbe sumele;
  • smoke test pe fluxurile critice, pentru că un hotfix făcut în grabă poate strica alte lucruri;
  • comunicarea clară a riscului rămas: ce nu s-a putut testa în timpul disponibil.

Dacă analiza de impact arată prea multe zone, recomand amânarea lansării sau un plan de rollback pregătit.

Ce urmărește intervievatorul: Verifică dacă știi să delimitezi testarea unei schimbări mici dar riscante. Greșeala tipică este să retestezi doar bug-ul reparat sau, invers, să ceri regresie completă fără prioritizare.

Greșeala, în practică:Retestare confundată cu regresiaRegresie sărită după o reparație

22 Senior

Cum ai testa o migrare de date, de exemplu mutarea clienților și a comenzilor dintr-o platformă veche de magazin online într-una nouă?

Răspuns scurt: Verifici completitudinea (toate înregistrările au ajuns), corectitudinea (valorile sunt aceleași), transformările (formate, coduri, statusuri), relațiile dintre date și faptul că aplicația nouă poate folosi datele migrate. Plus o repetiție completă și un plan de revenire.

O migrare de date pică rar spectaculos, dar des în detalii care se văd luni mai târziu. Strategia mea ar avea câteva straturi:

  • înțelegerea mapării: documentul care spune ce câmp vechi devine ce câmp nou, ce se transformă (statusuri „expediat” → SHIPPED, telefoane aduse la același format), ce nu se migrează și de ce;
  • completitudine: numărători pe tabele și pe categorii (clienți activi, comenzi pe an, sume totale pe lună) comparate între sursă și destinație, de obicei cu interogări SQL făcute de mine sau de un developer;
  • corectitudine pe eșantioane: aleg înregistrări reprezentative și pe cele ciudate (clienți cu diacritice în nume, adrese foarte lungi, comenzi anulate parțial, retururi, conturi șterse, valori nule, date din anii în care s-a schimbat cota de TVA) și le compar câmp cu câmp;
  • relații: fiecare comandă are clientul ei, produsele există, facturile se leagă de comenzi;
  • folosire în aplicația nouă: un client migrat se poate loga (parolele migrate corect sau resetare forțată, cu comunicare), își vede istoricul, poate face retur la o comandă veche;
  • nefuncțional: durata migrării în fereastra disponibilă, comportamentul la reluare dacă procesul se oprește la jumătate;
  • repetiția completă (dry run) pe o copie anonimizată a datelor de producție, cu criterii clare de acceptare;
  • planul de revenire: ce facem dacă după migrare descoperim probleme mari.

După migrarea reală, rulez rapid verificările de reconciliere și un smoke test, apoi urmăresc reclamațiile din primele zile.

Ce urmărește intervievatorul: Întrebarea de senior verifică dacă poți organiza testarea unui proiect riscant, nu doar al unei funcționalități. Răspunsul slab se rezumă la „verific că datele sunt acolo”.

Tehnici de proiectare a testelor

Exersează capitolul cu exerciții reale: Curs testare manuală pentru începători →
23 Junior

Aplică partiționarea în clase de echivalență pe un câmp de email la înregistrare. De ce nu combini două valori invalide în același caz de test?

Răspuns scurt: Clase valide: email cu format corect, nefolosit. Clase invalide: fără @, fără domeniu, cu spații, prea lung, câmp gol, email deja înregistrat. Combini mai multe valori valide într-un test, dar fiecare invalidă separat, ca un defect să nu-l mascheze pe altul.

Partiționarea pornește de la ideea că valorile dintr-o clasă sunt tratate la fel de sistem, deci e suficient un reprezentant. Pentru email, cu regulile tipice ale unui formular:

Clase valide:

  • format standard: ana.pop@exemplu.ro;
  • variante permise, dacă cerința le acceptă: subdomeniu, + în partea locală (ana+magazin@exemplu.ro), domenii de nivel superior lungi (.online).

Clase invalide:

  • gol;
  • fără @: ana.exemplu.ro;
  • fără parte locală sau fără domeniu: @exemplu.ro, ana@;
  • două @;
  • spații în interior;
  • peste lungimea maximă (standardul limitează adresa la 254 de caractere);
  • email deja folosit în sistem, inclusiv scris cu alte majuscule (Ana.Pop@Exemplu.ro).

Spațiile la început și la sfârșit sunt un caz de discutat: multe aplicații le elimină automat, iar comportamentul trebuie decis explicit.

De ce o singură valoare invalidă per test: dacă trimiți @ exemplu (fără parte locală și cu spațiu) și primești eroarea așteptată, nu știi care dintre cele două verificări a funcționat. Poate validarea pentru spații lipsește cu totul, dar e ascunsă de cea pentru parte locală. Valorile valide se pot combina liber, pentru că un test valid trebuie să treacă oricum. Asta e regula de mascare a defectelor din tehnică.

Ce urmărește intervievatorul: Verifică aplicarea corectă a tehnicii pe un câmp de text, nu doar pe intervale numerice. Greșeala tipică este un singur test „email invalid” sau combinarea mai multor invalide.

Greșeala, în practică:Doar teste pozitive („happy path”)Clase de echivalență invalide uitate

24 Junior

Parola trebuie să aibă între 8 și 20 de caractere. Ce lungimi testezi cu analiza valorilor limită în varianta cu 2 valori și în cea cu 3 valori?

Răspuns scurt: Cu 2 valori: 7, 8, 20, 21. Cu 3 valori: 7, 8, 9 și 19, 20, 21. Plus, separat, câmpul gol și o valoare foarte mare, care nu sunt limite propriu-zise, dar prind des defecte.

Analiza valorilor limită se aplică pe partiții ordonate: lungimea parolei are partiția invalidă 0–7, cea validă 8–20 și cea invalidă 21+. Defectele apar des la granițe, pentru că developerul scrie < în loc de <= sau numără greșit.

Varianta cu 2 valori ia, pentru fiecare limită, valoarea de pe limită și vecina din partiția alăturată:

  • limita de jos: 7 (invalid) și 8 (valid);
  • limita de sus: 20 (valid) și 21 (invalid).

Varianta cu 3 valori ia limita și ambii vecini:

  • jos: 7, 8, 9;
  • sus: 19, 20, 21.

A treia valoare prinde defecte de tipul unei condiții scrise lungime == 8 în loc de lungime >= 8, pe care varianta cu 2 valori nu le-ar observa la limita de jos.

Ca să faci testele eficient, pregătește parolele dinainte și numără-le cu un utilitar, nu din ochi: Abcdef1! are exact 8 caractere. Atenție la lucrurile care schimbă lungimea fără să se vadă: spațiile de la capete (sunt eliminate sau numărate?), diacriticele și emoji-urile (unele sisteme numără octeți, nu caractere, iar „ș” ocupă doi octeți în UTF-8). Verifică și ce face câmpul la 21 de caractere: refuză la salvare cu mesaj clar sau taie textul fără să spună? Tăierea tăcută e un defect clasic, mai ales când utilizatorul își lipește parola dintr-un manager de parole.

Ce urmărește intervievatorul: Verifică stăpânirea ambelor variante din ISTQB 4.0 și calculul corect al vecinilor. Greșeala tipică este să alegi 8 și 20 plus valori „din mijloc”, fără vecinii invalizi.

Greșeala, în practică:Lipsa testării valorilor limităTestată doar limita de jos

25 Junior

Ce valori de test alegi pentru un câmp „data nașterii” la un formular în care utilizatorul trebuie să aibă minimum 18 ani?

Răspuns scurt: Valori de format (zi și lună invalide, 29 februarie în an bisect și nebisect, 31 aprilie), limita de vârstă exact azi (împlinește 18 ani azi, ieri, mâine), date din viitor, date foarte vechi și câmpul gol.

Câmpul de dată combină două probleme: validitatea calendaristică și regula de business. Le tratez separat.

Validitatea datei:

  • zi 0 și 32, lună 0 și 13;
  • 31 aprilie (aprilie are 30 de zile);
  • 29 februarie 2024 (an bisect, valid) și 29 februarie 2025 (invalid);
  • 29 februarie 1900 (invalid: 1900 nu e bisect, fiind divizibil cu 100, dar nu cu 400) și 29 februarie 2000 (valid);
  • formate diferite: 31.10.2008, 31/10/2008, 2008-10-31, litere, doar anul;
  • câmp gol.

Regula de 18 ani, presupunând că testăm pe 31 octombrie 2026:

  • născut pe 31.10.2008: împlinește 18 ani azi, deci trebuie acceptat;
  • născut pe 01.11.2008: împlinește mâine, deci respins;
  • născut pe 30.10.2008: acceptat;
  • persoană născută pe 29 februarie, pentru anii nebisecți: când împlinește vârsta? Regula trebuie stabilită cu Product Owner-ul.

Alte partiții: data de azi, o dată din viitor, o vârstă nerealistă (născut în 1890).

Detalii care produc des defecte: fusul orar (serverul în UTC calculează vârsta cu o zi greșit în jurul miezului nopții), selectorul de dată diferit în Safari și pe mobil, posibilitatea de a scrie data manual față de alegerea din calendar. Pentru că limita depinde de ziua testului, datele de test se recalculează la fiecare rulare.

Ce urmărește intervievatorul: Verifică dacă aplici valorile limită pe un tip de date mai dificil decât un număr. Greșeala tipică este să uiți că limita de vârstă se mișcă în fiecare zi și de anii bisecți.

26 Junior

Ce este testarea bazată pe cazuri de utilizare (use case testing)? Cum derivi teste dintr-un use case „Retragere numerar”?

Răspuns scurt: Un use case descrie interacțiunea unui actor cu sistemul: flux principal, fluxuri alternative și excepții. Scrii cel puțin un test pentru fluxul principal și câte unul pentru fiecare flux alternativ și fiecare excepție.

Use case-ul descrie, din perspectiva unui actor (client, administrator, alt sistem), cum se atinge un scop. Are precondiții, un flux principal (drumul fericit), fluxuri alternative (alte drumuri valide spre scop) și excepții (situații în care scopul nu e atins). Tehnica apare în programa ISTQB 3.1; în versiunea 4.0 a fost scoasă din lista tehnicilor, dar rămâne folosită în practică și cerută la interviuri.

Pentru „Retragere numerar” la un bancomat:

  • flux principal: clientul introduce cardul, PIN-ul corect, alege suma de 200 lei, primește banii și cardul, contul scade cu 200 lei;
  • fluxuri alternative: alege „altă sumă” și introduce 350 lei; cere chitanță; alege altă limbă la început;
  • excepții: PIN greșit o dată și apoi corect; PIN greșit de trei ori, cardul e reținut; fonduri insuficiente; suma depășește limita zilnică; bancomatul nu are bancnote de valoarea cerută; clientul nu ia banii în timpul permis; cardul expirat; pierderea conexiunii cu banca după ce suma a fost debitată, dar înainte de eliberarea banilor.

Fiecare dintre acestea devine cel puțin un caz de test. Acoperirea se măsoară ca procent din fluxuri exercitate.

Avantajul tehnicii: testele sunt aproape de felul în care sistemul e folosit, deci prind probleme de integrare și de flux pe care testele pe câmpuri izolate nu le văd. Limita ei: nu spune nimic despre valorile limită ale sumei, pe care le adaugi cu altă tehnică.

Ce urmărește intervievatorul: Verifică dacă știi să transformi un document de flux în teste, inclusiv excepțiile. Greșeala tipică este să testezi doar fluxul principal.

27 Junior

Ce este ghicirea erorilor (error guessing)? Dă exemple de erori pe care le „ghicești” pe aproape orice formular web.

Răspuns scurt: E o tehnică bazată pe experiență: anticipezi unde au greșit probabil developerii, pe baza defectelor văzute înainte. Pe formulare: dublu click la trimitere, spații la capete, caractere speciale, lipire de text lung, butonul Înapoi după trimitere, câmpuri obligatorii ascunse.

Ghicirea erorilor folosește cunoștințele testerului despre: cum s-a comportat aplicația în trecut, ce greșeli fac des developerii și ce defecte au apărut în aplicații similare. Varianta structurată se numește atac de defecte (fault attack): îți faci o listă de erori posibile și proiectezi teste care să le provoace.

Lista mea pentru aproape orice formular:

  • dublu click sau click repetat pe „Trimite”: se creează două comenzi sau două conturi?
  • spații la început, la sfârșit sau doar spații într-un câmp obligatoriu;
  • apostrof și ghilimele (O'Brien), diacritice, emoji, caractere chinezești;
  • text foarte lung lipit din clipboard, peste limita câmpului;
  • valori numerice cu virgulă și cu punct, cu zero în față, negative, cu spații între cifre;
  • butonul Înapoi după trimitere, apoi retrimitere; reîncărcarea paginii cu F5;
  • pierderea sesiunii între completare și trimitere (formular lăsat deschis o oră);
  • autocompletarea browserului care completează câmpuri ascunse;
  • validare doar în frontend, ocolită prin DevTools sau Postman;
  • două taburi deschise cu același formular;
  • mesajul de eroare care golește tot formularul.

Tehnica e eficientă, dar depinde de experiența testerului și nu oferă o măsură de acoperire. De aceea nu o folosești singură, ci în completarea tehnicilor bazate pe specificație. Un obicei bun: după fiecare proiect, adaugi în listă defectele interesante găsite, ca lista să crească cu experiența ta.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă o listă personală de capcane, semn de experiență reală. Greșeala tipică e un răspuns teoretic fără niciun exemplu concret.

Greșeala, în practică:Text foarte lung netestatSpații la capete netestate

28 Junior

Cerința spune: „Livrare gratuită pentru comenzi de la 200 lei inclusiv; 15 lei pentru comenzi între 100 și 199,99 lei; 25 lei sub 100 lei.” Developerul a scris codul de mai jos. Ce valori testezi și ce defecte găsești?

JavaScript
function costLivrare(total) {
  if (total > 200) return 0;
  if (total > 100) return 15;
  return 25;
}

Răspuns scurt: Testezi limitele 99,99, 100, 199,99 și 200. Codul are două defecte: la exact 200 lei întoarce 15 în loc de 0, iar la exact 100 lei întoarce 25 în loc de 15, pentru că folosește > în loc de >=.

Mai întâi împart intervalul în partiții după cerință: sub 100 lei (25 lei livrare), 100–199,99 lei (15 lei), de la 200 lei (gratuit). Valorile limită, cu pasul de un ban, sunt 99,99 / 100 și 199,99 / 200. Adaug câte o valoare din mijlocul fiecărei partiții (50, 150, 500) și valori speciale: 0, negativ, o valoare cu mai multe zecimale.

Rulând mental codul:

  • costLivrare(99.99) → 25, corect;
  • costLivrare(100) → 100 > 100 e fals, deci 25. Așteptat: 15. Defect.
  • costLivrare(199.99) → 15, corect;
  • costLivrare(200) → 200 > 200 e fals, apoi 200 > 100 e adevărat, deci 15. Așteptat: 0. Defect.
  • costLivrare(500) → 0, corect.

Corectura este >= în ambele condiții:

JavaScript
function costLivrare(total) {
  if (total >= 200) return 0;
  if (total >= 100) return 15;
  return 25;
}

Ca tester manual, nu e nevoie să citești codul: aceleași defecte ies din testarea prin interfață cu un coș de exact 100 și exact 200 lei. Exemplul arată de ce valorile limită sunt tehnica cu cel mai bun raport cost-beneficiu. Întrebări suplimentare pentru Product Owner: totalul include sau nu reducerile și TVA-ul? Ce se întâmplă dacă un cupon scade totalul sub 200 lei după ce livrarea a fost calculată ca gratuită?

Ce urmărește intervievatorul: Verifică dacă legi valorile limită de un defect real de tip off-by-one și dacă poți citi un cod simplu. Mulți candidați testează doar 50, 150 și 250 și ratează ambele defecte.

Greșeala, în practică:Lipsa testării valorilor limităTestată doar limita de jos

29 Mid

Un magazin oferă reducere de 10% studenților și 5% celor cu card de fidelitate; reducerile nu se cumulează, iar studentul cu card primește 10%. În plus, reducerea se aplică doar la comenzi de minimum 100 lei. Construiește tabelul de decizie și simplifică-l.

Răspuns scurt: Trei condiții binare dau 8 reguli. Toate cele cu comanda sub 100 lei dau 0% și se comasează. Rămân 4: sub 100 lei → 0%; student → 10%; doar card → 5%; nici student, nici card → 0%.

Condițiile: C1 student (D/N), C2 card de fidelitate (D/N), C3 comandă de minimum 100 lei (D/N). Acțiunea: procentul de reducere. Tabelul complet are 2³ = 8 reguli:

Regula        1    2    3    4    5    6    7    8
Student       D    D    D    D    N    N    N    N
Card          D    D    N    N    D    D    N    N
>= 100 lei    D    N    D    N    D    N    D    N
Reducere     10%   0   10%   0   5%    0    0    0

Simplificare: regulile 2, 4, 6 și 8 au aceeași acțiune (0%) indiferent de student și card, deci le comasez într-o regulă cu „—” (nu contează) pe primele două condiții. Regulile 1 și 3 dau 10% indiferent de card, deci se comasează și ele:

Regula        A    B    C    D
Student       —    D    N    N
Card          —    —    D    N
>= 100 lei    N    D    D    D
Reducere      0   10%   5%   0

Din fiecare coloană rezultă cel puțin un caz de test, cu date concrete: student cu card și comandă de 99,99 lei (regula A, care verifică și limita), student cu card și 100 lei (B; prinde cumularea greșită 15%), client doar cu card și 250 lei (C), client fără nimic și 250 lei (D).

Atenție: comasarea reduce numărul de teste, dar asumă că implementarea respectă exact regula „nu contează”. Dacă riscul e mare, testezi și combinațiile comasate. Tabelul a scos și o întrebare: pragul de 100 lei se aplică înainte sau după alte promoții?

Ce urmărește intervievatorul: Verifică dacă știi să construiești, nu doar să definești, un tabel de decizie și să-l reduci corect. Greșeala tipică este omiterea regulilor sau comasarea a două reguli cu acțiuni diferite.

Greșeala, în practică:Tabel de decizie cu combinații lipsă

30 Mid

O comandă are stările: Nouă, Plătită, Expediată, Livrată, Anulată. Poate fi anulată doar înainte de expediere. Cum proiectezi testele cu tehnica tranzițiilor de stare și ce înseamnă acoperirea tranzițiilor valide față de toate tranzițiile?

Răspuns scurt: Desenezi diagrama, apoi faci un test pentru fiecare tranziție validă (Nouă→Plătită, Plătită→Expediată, Expediată→Livrată, Nouă→Anulată, Plătită→Anulată) și încerci explicit tranzițiile interzise, de exemplu Expediată→Anulată sau Livrată→Plătită.

Mai întâi scriu tranzițiile valide, cu evenimentul care le declanșează:

Nouă      --plată confirmată-->  Plătită
Nouă      --anulare client-->    Anulată
Plătită   --predare curier-->    Expediată
Plătită   --anulare client-->    Anulată   (cu rambursare)
Expediată --confirmare curier--> Livrată

Livrată și Anulată sunt stări finale. Apoi construiesc tabelul de stări: 5 stări × 4 evenimente = 20 de celule. Cele 5 de mai sus sunt valide, restul sunt invalide și sistemul trebuie să le refuze.

Programa ISTQB 4.0 definește trei niveluri de acoperire:

  • toate stările: fiecare stare e vizitată cel puțin o dată; două teste ajung (Nouă→Plătită→Expediată→Livrată și Nouă→Anulată);
  • tranziții valide (0-switch): fiecare tranziție validă e exercitată; adaug Plătită→Anulată și verific rambursarea;
  • toate tranzițiile: valide plus încercarea fiecărei tranziții invalide. Exemple de încercat: anulare după expediere (butonul nu apare, iar un apel direct la API e refuzat), plată pe o comandă deja anulată, confirmare de livrare pentru o comandă neexpediată.

Tranzițiile invalide prind cele mai multe defecte grave, pentru că developerii ascund butonul în interfață, dar uită să blocheze acțiunea în backend. Le testez și din Postman, și cu două taburi deschise: într-unul anulez, în celălalt, încă neactualizat, încerc să plătesc.

Verific la fiecare tranziție și efectele: email trimis, stocul eliberat la anulare, istoricul comenzii actualizat.

Ce urmărește intervievatorul: Verifică dacă știi să modelezi stări și să testezi tranzițiile interzise, nu doar fluxul normal. Candidații ratează de obicei tranzițiile invalide și efectele secundare.

Greșeala, în practică:Tranziții de stare invalide netestate

31 Mid

Ce diferență este între tehnicile bazate pe specificație, cele bazate pe experiență și cele bazate pe colaborare? Când alegi una sau alta?

Răspuns scurt: Tehnicile bazate pe specificație (black-box) derivă teste din cerințe; cele bazate pe experiență folosesc cunoștințele testerului (exploratory, error guessing, checklisturi); cele bazate pe colaborare previn defectele scriind împreună story-uri și criterii de acceptare. În practică le combini.

Programa ISTQB 4.0 grupează tehnicile în patru familii: black-box (bazate pe specificație), white-box (bazate pe structura codului), bazate pe experiență și abordări bazate pe colaborare.

Bazate pe specificație: clase de echivalență, valori limită, tabele de decizie, tranziții de stare. Sunt sistematice, repetabile și oferă o măsură de acoperire. Le alegi când ai cerințe clare și riscul e mare: calcul de prețuri, reguli de eligibilitate, fluxuri cu stări.

Bazate pe experiență: ghicirea erorilor, testarea exploratorie, testarea pe checklist. Sunt rapide și găsesc ce nu e scris nicăieri, dar depind de om și se măsoară greu. Le alegi când documentația e slabă, timpul e scurt, sau ca a doua trecere după testele scriptate.

Bazate pe colaborare: scrierea împreună a user stories, a criteriilor de acceptare și ATDD (Acceptance Test-Driven Development, adică testele de acceptanță scrise înainte de implementare). Accentul cade pe evitarea defectelor prin înțelegere comună, nu pe găsirea lor ulterioară.

Factorii de alegere: riscul funcționalității, tipul de sistem, calitatea documentației, timpul, cerințele contractuale sau de reglementare, experiența echipei.

Exemplu realist pentru un formular de credit: în refinement lămuresc criteriile cu Product Owner-ul (colaborare), aplic valori limită pe sumă și perioadă și un tabel de decizie pe eligibilitate (specificație), apoi o sesiune exploratorie de o oră pe flux, cu lista mea de capcane (experiență).

Ce urmărește intervievatorul: Verifică dacă vezi tehnicile ca instrumente pentru contexte diferite, nu ca listă de definiții. Greșeala tipică este să spui că una e mereu mai bună decât celelalte.

32 Mid

Testează un calculator de rate: suma între 1.000 și 50.000 lei, perioada între 6 și 60 de luni, dobândă fixă afișată. Ce tehnici combini și ce teste concrete scrii?

Răspuns scurt: Combini clase de echivalență și valori limită pe fiecare câmp, un oracol independent pentru rată (formula în Excel), verifici rotunjirile și totalul plătit, plus teste de interfață: separatori, recalculare la schimbare, câmpuri goale.

Pe fiecare intrare aplic partiții și valori limită, testând o singură valoare invalidă pe rând:

  • suma: 999 / 1.000 / 1.001 și 49.999 / 50.000 / 50.001; plus gol, 0, negativ, zecimale (1.000,50), litere, spații, scrierea „10.000” față de „10000”;
  • perioada: 5 / 6 / 7 și 59 / 60 / 61 de luni; plus zecimale (12,5) și valori din mijloc;
  • dacă perioada se alege dintr-o listă, verific doar că lista conține exact valorile permise.

Pentru corectitudinea calculului am nevoie de un oracol independent. Pentru rata fixă (anuitate), formula standard este:

rata = S * r / (1 - (1 + r)^(-n))
S = suma, n = numărul de luni, r = dobânda anuală / 12

În Excel, aceeași valoare o dă funcția PMT. Compar rata, totalul de plată și dobânda totală pentru câteva combinații: minim-minim, maxim-maxim, valori obișnuite. Discut cu Product Owner-ul despre rotunjire: la doi zecimali, pe fiecare rată sau doar la final? Diferența de câțiva bani pe rată devine vizibilă la total.

Teste de interfață și flux:

  • recalcularea la schimbarea oricărui câmp, fără reîncărcare;
  • rezultatul nu rămâne afișat după ce introduc o valoare invalidă;
  • formatul monedei și al separatorilor în română;
  • slider și câmp text sincronizate, dacă există amândouă;
  • comportamentul pe mobil și cu tastatura numerică.

La final, câteva teste exploratorii: lipire de valori, tastare foarte rapidă, schimbarea limbii.

Ce urmărește intervievatorul: Verifică dacă știi să combini tehnici pe o problemă realistă și dacă te gândești la oracol. Greșeala tipică este să testezi intrările perfect, dar să nu verifici dacă rata calculată e corectă.

33 Mid

Cum organizezi o sesiune de testare exploratorie pe sesiuni (session-based testing)? Scrie un charter pentru funcționalitatea de retur a unei comenzi.

Răspuns scurt: Fiecare sesiune are o durată fixă (de obicei 60–120 de minute), un charter cu misiunea, notițe în timpul explorării și un debriefing la final. Charter-ul spune ce explorezi, cu ce resurse și ce informație cauți.

Testarea exploratorie nu înseamnă „dau click-uri la întâmplare”. Varianta structurată, session-based test management, are câteva elemente:

  • charter: misiunea sesiunii, pe scurt;
  • timebox: durată fixă și neîntreruptă, de exemplu 90 de minute;
  • notițe: ce ai testat, ce idei ți-au venit, defectele, întrebările, zonele neacoperite;
  • debriefing: o discuție scurtă cu lead-ul sau cu echipa la final: ce ai aflat, ce riscuri rămân, merită încă o sesiune?

Un format popular de charter, propus de Elisabeth Hendrickson, este „Explorează [ținta] cu [resursele] ca să descoperi [informația]”. Pentru retur:

Charter: Explorează fluxul de retur al unei comenzi livrate,
cu conturi care au comenzi parțial returnate, produse la reducere
și plăți cu card și ramburs, ca să descoperi probleme în calculul
sumei rambursate și în statusurile comenzii.
Durată: 90 de minute
Date: 3 conturi de test, comenzi livrate acum 2, 13 și 15 zile
Ieșiri: notițe, defecte raportate, întrebări pentru PO

Idei de explorat în sesiune: retur la limita termenului legal de 14 zile, retur parțial urmat de alt retur, produs cumpărat cu cupon (cât se rambursează?), retur pe o comandă cu livrare gratuită care scade sub prag, două cereri de retur trimise simultan.

Notițele includ și procentul de timp petrecut efectiv testând, față de pregătire și raportare. Asta ajută la planificare și arată managerului că explorarea e măsurabilă.

Ce urmărește intervievatorul: Verifică dacă știi să faci testarea exploratorie disciplinată și raportabilă. Candidații care spun doar „testez liber, fără documentație” par lipsiți de metodă.

Greșeala, în practică:Testare exploratorie fără charter

34 Senior

Primești o funcționalitate complexă: calculul primei de asigurare auto, cu 12 factori (vârstă, vechime permis, zonă, istoric daune etc.). Combinațiile sunt de ordinul milioanelor. Cum decizi ce teste scrii și când te oprești?

Răspuns scurt: Împarți problema: partiții și limite pe fiecare factor, tabele de decizie pe regulile care interacționează, testare combinatorială (pairwise) pentru restul, un oracol independent pentru calcul și prioritizare după risc. Te oprești când criteriile de acoperire convenite sunt atinse.

Nu încerc să acopăr toate combinațiile. Lucrez în straturi:

  • lămuresc regulile: obțin specificația actuarială sau un tabel de tarife și verific cu cine l-a scris cum interacționează factorii; de multe ori, doar câțiva factori interacționează între ei, iar ceilalți sunt multiplicatori independenți;
  • factorii independenți: clase de echivalență și valori limită pe fiecare (vârsta 17/18/19, 25/26, 69/70, dacă acolo se schimbă coeficientul; vechimea permisului 0, 1, 2 ani);
  • factorii care interacționează: tabel de decizie pentru acele reguli (de exemplu, un șofer sub 25 de ani, cu permis sub 2 ani și daune în ultimul an);
  • restul combinațiilor: testare combinatorială pe perechi (pairwise), generată cu o unealtă precum PICT, ca fiecare pereche de valori să apară cel puțin o dată, cu un număr mic de teste;
  • oracol independent: un fișier Excel făcut de echipa de business sau de mine după formula din specificație; compar rezultatele pentru zeci de profiluri, eventual automatizat;
  • profiluri reale: dacă există un sistem vechi, compar pe un eșantion de clienți reali anonimizați;
  • risc: profilurile cele mai frecvente și cele cu impact financiar mare primesc teste suplimentare.

Mă opresc când criteriile convenite sunt atinse: fiecare regulă din tabel e acoperită, toate perechile sunt acoperite, profilurile de risc au trecut, iar defectele rămase sunt evaluate. Riscul rămas îl comunic explicit, de exemplu: „interacțiunile de ordin 3 între factorii X, Y, Z nu sunt acoperite complet”.

Ce urmărește intervievatorul: Întrebarea de senior verifică dacă poți controla explozia combinatorială cu tehnici și argumente, nu cu ore suplimentare. Răspunsul slab este „testez cât pot” fără criteriu de oprire.

Greșeala, în practică:Testare exhaustivă încercată

Cazuri de test și execuție

35 Junior

Ce sunt precondițiile și datele de test într-un caz de test? De ce un caz de test fără ele nu e repetabil?

Răspuns scurt: Precondițiile descriu starea sistemului înainte de primul pas (cont existent, produs în stoc, utilizator logat), iar datele de test sunt valorile concrete folosite. Fără ele, altcineva pornește din altă stare, cu alte date, și obține alt rezultat.

Un caz de test bun trebuie să dea același rezultat oricui îl rulează. Asta depinde de două lucruri care lipsesc des la juniori.

Precondițiile spun în ce stare trebuie să fie sistemul și mediul:

  • utilizatorul test.client1@exemplu.ro există, are adresă salvată și nicio comandă în curs;
  • produsul „Cană albastră” (cod CA-01) are stoc 5 și preț 39,90 lei;
  • cuponul TOAMNA10 e activ și nefolosit de acest cont;
  • testul rulează pe mediul de test, build 2.14.

Datele de test sunt valorile introduse efectiv: cantitatea 2, cuponul TOAMNA10, cardul de test al procesatorului de plăți.

Fără ele, apar probleme previzibile. Un coleg rulează testul cu un cont care a folosit deja cuponul și marchează Fail, deși aplicația e corectă. Rezultatul așteptat „totalul e corect” devine imposibil de verificat dacă nu știi prețul și cantitatea. Un test care trecea ieri pică azi pentru că stocul s-a terminat.

Câteva practici bune:

  • scrie rezultatul așteptat cu valori concrete: „Total: 71,82 lei (79,80 − 10%)”;
  • separă datele care se consumă (cupoane, stoc, conturi noi) și spune cum se refac;
  • unde se poate, pregătește datele prin API sau prin scripturi SQL, nu manual prin interfață;
  • adaugă pași de curățare (postcondiții), ca testul următor să nu fie afectat.

Ce urmărește intervievatorul: Verifică dacă scrii cazuri de test pe care le poate rula altcineva. Greșeala tipică este precondiția vagă „utilizator logat” și rezultatul așteptat fără valori.

Greșeala, în practică:Caz de test fără precondițiiCaz de test fără date de test concrete

36 Junior

Scrie cazuri de test pozitive și negative pentru câmpul „cantitate” din coșul unui magazin online, unde stocul produsului este 10.

Răspuns scurt: Pozitive: cantitatea 1, 5, 10, totalul se recalculează. Negative: 0, 11, valoare negativă, zecimale, litere, gol, valoare foarte mare. Verifici și mesajul de eroare, valoarea rămasă în câmp și totalul după fiecare încercare.

Cazurile pozitive confirmă că funcționalitatea merge cu date valide; cele negative verifică dacă sistemul tratează corect datele invalide, fără să se strice. Presupun că minimul e 1 și maximul e stocul, adică 10.

Pozitive:

  • cantitatea 1 (minim): totalul e egal cu prețul;
  • cantitatea 10 (maxim, egală cu stocul): acceptată;
  • cantitatea 5, apoi modificată în 3: totalul se recalculează corect, fără reîncărcarea paginii;
  • butoanele „+” și „−” modifică valoarea cu 1;
  • cantitatea rămâne după reîncărcarea paginii și după logout/login, dacă coșul se salvează.

Negative:

  • 0: produsul e eliminat cu confirmare sau valoarea e refuzată, conform cerinței;
  • 11 (peste stoc): mesaj clar de tipul „Sunt disponibile doar 10 bucăți”;
  • −1, 2,5, „abc”, câmp gol, spații;
  • 99999999999 (depășirea limitelor numerice);
  • butonul „−” la cantitatea 1 și „+” la 10: nu trebuie să treacă de limite;
  • între timp alt client cumpără ultimele bucăți: ce se întâmplă la checkout?

Pentru fiecare negativ verific trei lucruri: mesajul (clar, lângă câmp), starea câmpului după eroare (revine la ultima valoare validă sau rămâne valoarea greșită?) și totalul (nu trebuie calculat cu o valoare invalidă, de exemplu un total negativ).

Ultimul punct merită testat și prin API, pentru că validarea din interfață se poate ocoli.

Ce urmărește intervievatorul: Verifică dacă gândești negativ în mod sistematic, nu doar „merge cu 2 bucăți”. Greșeala tipică este să verifici doar că apare eroarea, nu și starea aplicației după ea.

Greșeala, în practică:Doar teste pozitive („happy path”)Clase de echivalență invalide uitate

37 Junior

Ce diferență este între un test marcat Fail și unul marcat Blocked? Când folosești Not Run sau Skipped?

Răspuns scurt: Fail înseamnă că testul a rulat și rezultatul obținut diferă de cel așteptat. Blocked înseamnă că nu poate fi rulat din cauza unei probleme externe lui (alt defect, mediu căzut, date lipsă). Not Run e un test planificat încă neexecutat; Skipped, unul exclus intenționat.

Statusurile de execuție se folosesc pentru raportare și decizii, deci confuzia lor duce la concluzii greșite.

  • Pass: testul a rulat complet, rezultatul obținut e cel așteptat.
  • Fail: testul a rulat, iar la un pas rezultatul obținut a fost diferit de cel așteptat. Se leagă de un raport de defect.
  • Blocked: testul nu poate fi executat sau dus la capăt din motive din afara lui. Exemple: login-ul e stricat, deci toate testele de checkout sunt blocate; mediul de test e căzut; lipsesc datele de test; funcționalitatea nu a fost încă livrată. Notezi motivul și, dacă e un defect, legi testul de el.
  • Not Run / Untested: testul e planificat, dar nu a fost încă executat.
  • Skipped / N/A: s-a decis conștient să nu fie rulat în acest ciclu (nu e relevant pentru build, e în afara scopului). Decizia trebuie să fie vizibilă, nu ascunsă.
  • În TestRail există și Retest, pentru teste care trebuie reluate după o reparație.

De ce contează: dacă marchezi „Fail” toate testele de checkout din cauza login-ului, raportul arată 40 de defecte în checkout, deși e unul singur, în login. Invers, dacă marchezi „Blocked” un test care a dat un rezultat greșit, defectul se pierde. Un număr mare de teste Blocked e un semnal pentru manager: problema nu e calitatea produsului, ci mediul sau dependențele, iar ea se rezolvă altfel.

Ce urmărește intervievatorul: Verifică precizia raportării și înțelegerea efectului statusurilor asupra deciziilor. Greșeala tipică este să marchezi Fail tot ce nu a mers, indiferent de cauză.

Greșeala, în practică:Fail în loc de BlockedCazuri lăsate Neexecutat

38 Junior

Un test a picat. Ce dovezi atașezi și ce notezi, ca rezultatul să fie de încredere și util developerului?

Răspuns scurt: Rezultatul obținut exact (textul mesajului, valoarea afișată), capturi sau înregistrare video, datele de test folosite, build-ul și mediul, ora, iar unde e cazul erorile din consolă, request-ul și răspunsul din Network sau un fișier HAR și ID-ul comenzii.

Un rezultat de execuție trebuie să poată fi verificat de altcineva, iar developerul trebuie să poată începe investigația fără să te întrebe nimic. Ce notez:

  • rezultatul obținut, exact: textul mesajului copiat, nu parafrazat; valoarea afișată („Total: 89,80 lei”), nu „total greșit”;
  • pasul la care a apărut diferența;
  • datele de test: contul, produsul, cuponul, ID-ul comenzii sau al utilizatorului creat;
  • mediul: URL-ul mediului, versiunea build-ului, browserul și versiunea lui, sistemul de operare, dispozitivul;
  • ora (cu fusul orar), ca developerul să găsească ușor logurile serverului;
  • captura de ecran cu zona relevantă marcată; pentru fluxuri sau probleme vizuale de durată, o înregistrare video scurtă;
  • erori tehnice: mesajele roșii din Console, request-ul care a eșuat din Network cu statusul și răspunsul, eventual un fișier HAR exportat din tab-ul Network;
  • pentru mobil: versiunea aplicației și logurile dispozitivului, dacă știi să le extragi.

Atenție la ce atașezi: fișierul HAR și capturile pot conține tokenuri de sesiune, parole sau date personale. Pe medii de test cu date reale anonimizate sau pe producție, elimină aceste informații înainte de a le pune într-un tichet vizibil pentru mulți oameni.

Dovezile contează și pentru testele trecute în domenii reglementate (bănci, medical), unde auditorii pot cere capturi și pentru Pass.

Ce urmărește intervievatorul: Verifică dacă dovezile tale scurtează investigația. Greșeala tipică este o captură fără context sau omiterea build-ului și a orei.

Greșeala, în practică:Raport fără captură de ecranFail fără rezultat obținut și fără bug

39 Junior

Ce probleme vezi la cazul de test de mai jos? Rescrie-l.

Titlu: Test login
Pași:
1. Intră pe site
2. Loghează-te
3. Verifică dacă merge
Rezultat așteptat: Merge

Răspuns scurt: Titlul nu spune ce se verifică, lipsesc precondițiile și datele, pașii sunt vagi, iar rezultatul așteptat nu poate fi verificat obiectiv. Un caz bun are un singur obiectiv, pași acționabili și un rezultat așteptat observabil.

Problemele:

  • titlul „Test login” nu spune care scenariu se verifică: login reușit, parolă greșită, cont blocat?
  • lipsesc precondițiile: ce cont există, pe ce mediu, în ce stare;
  • „Intră pe site”: care URL?
  • „Loghează-te”: cu ce date, de unde pornești, ce butoane apeși?
  • „Verifică dacă merge” și „Merge” nu sunt verificabile: doi testeri vor înțelege lucruri diferite;
  • nu are prioritate și nici legătură cu o cerință.

Varianta rescrisă:

ID: TC-LOGIN-01
Titlu: Login reușit cu email și parolă valide redirecționează
       spre pagina contului
Cerință: US-31
Prioritate: Înaltă
Precondiții: pe mediul de test există contul activ
  test.client1@exemplu.ro / parola de test din fișierul de date;
  utilizatorul nu este logat
Pași:
1. Deschide https://test.exemplu.ro/login
2. Introdu emailul test.client1@exemplu.ro
3. Introdu parola contului de test
4. Apasă „Intră în cont”
Rezultat așteptat:
- se deschide pagina /contul-meu
- în antet apare „Bună, Ana”
- butonul „Intră în cont” este înlocuit cu „Ieși din cont”

Observații: un caz verifică un singur lucru, așa că parola greșită și contul blocat devin cazuri separate. Pașii pot fi urmați de cineva care nu a văzut niciodată aplicația. Parola nu se scrie în clar în cazul de test, ci se ia din datele de test ale proiectului.

Ce urmărește intervievatorul: Exercițiul arată imediat dacă știi să scrii un caz de test executabil de altcineva. Greșeala tipică în varianta rescrisă este să pui mai multe verificări diferite într-un singur caz.

Greșeala, în practică:Caz de test prea generalCaz de test fără rezultat așteptat

40 Junior

Ce este o suită de teste? Cum ai organiza suitele pentru un magazin online astfel încât să poți rula rapid un smoke, o regresie sau doar testele unei funcționalități?

Răspuns scurt: O suită e un set de cazuri de test grupate pentru a fi rulate împreună. Le organizezi pe funcționalități (secțiuni: cont, coș, checkout) și le marchezi cu atribute precum prioritatea sau tipul (smoke, regresie), ca să poți construi rulări diferite din același depozit.

Structura care funcționează cel mai bine în practică are două dimensiuni.

Dimensiunea 1, pe funcționalități: o ierarhie de secțiuni, care oglindește aplicația:

Magazin online
  Cont: înregistrare, login, resetare parolă, profil
  Catalog: căutare, filtre, pagina produsului
  Coș: adăugare, cantități, cupoane
  Checkout: adresă, livrare, plată, confirmare
  Comenzi: istoric, retur, facturi
  Administrare: produse, comenzi, rapoarte

Dimensiunea 2, atribute pe fiecare caz: prioritate (Critică, Înaltă, Medie, Joasă), tip (smoke, regresie, funcțional nou), platformă (web, mobil), automatizat sau nu, cerința legată.

Din aceste atribute construiești rulări (test runs) fără să dublezi cazurile:

  • smoke: cazurile marcate smoke, din toate secțiunile, 15–20 de bucăți;
  • regresie completă: toate cazurile de regresie;
  • regresie țintită: secțiunea Checkout plus cazurile critice din rest, după o schimbare la plăți;
  • funcționalitate nouă: cazurile legate de story-urile din sprint.

În TestRail, asta înseamnă un depozit de cazuri organizat în secțiuni, cu câmpuri personalizate și filtre la crearea rulărilor. Ce evit: copierea acelorași cazuri în mai multe suite (se desincronizează la prima modificare), suite numite după sprinturi („Sprint 14”), care devin inutile după o lună, și cazurile care depind de ordinea rulării fără să o spună.

Ce urmărește intervievatorul: Verifică dacă gândești organizarea testware-ului pe termen lung. Greșeala tipică este duplicarea cazurilor în mai multe suite.

Greșeala, în practică:Cazuri neorganizate în suite

41 Mid

Ce diferență este între un caz de test de nivel înalt (logic) și unul de nivel scăzut (concret)? Cum decizi cât de detaliat scrii?

Răspuns scurt: Cazul de nivel înalt spune ce se testează, fără date și pași exacți („aplică un cupon expirat, primești eroare”). Cel de nivel scăzut are date, pași și rezultat exact. Decizi după cine rulează testul, cât de stabil e produsul, riscul și cerințele de audit.

Cazurile de nivel înalt (logice) descriu intenția: „Verifică că un cupon expirat nu poate fi aplicat și că apare un mesaj explicativ.” Testerul alege datele și pașii la execuție. Cazurile de nivel scăzut (concrete) au tot: cuponul VARA2025, expirat pe 31.08.2025, contul X, pașii 1–6, mesajul exact „Cuponul a expirat”.

Avantaje și dezavantaje:

  • nivelul înalt se scrie și se întreține repede, lasă loc variației (combate paradoxul pesticidului), dar rezultatele depind de cine rulează și se compară greu între rulări;
  • nivelul scăzut e repetabil, potrivit pentru începători și pentru audit, ușor de automatizat ulterior, dar costă mult de scris și se învechește la fiecare schimbare de interfață.

Criteriile mele de decizie:

  • cine execută: testeri noi, colegi din altă echipă sau utilizatori la UAT au nevoie de detalii; un tester care cunoaște produsul se descurcă cu cazuri logice;
  • riscul: calcule financiare și fluxuri critice primesc rezultate așteptate exacte;
  • reglementarea: în domenii auditate (medical, bancar), detaliul și dovezile pot fi obligatorii;
  • stabilitatea interfeței: pe o funcționalitate care se schimbă în fiecare sprint, nivelul înalt evită rescrierea constantă;
  • automatizarea planificată: un caz concret e o specificație bună pentru un test automat.

Un compromis bun: cazuri logice cu datele de test într-un fișier separat și rezultate exacte doar acolo unde contează valoarea.

Ce urmărește intervievatorul: Verifică dacă înțelegi costul documentației și știi să-l justifici. Greșeala tipică este să pretinzi că toate cazurile trebuie scrise la detaliu maxim.

Greșeala, în practică:Caz de test prea general

42 Mid

Ai 120 de cazuri de test pentru un release și știi că nu vei apuca să le rulezi pe toate. Cum stabilești ordinea de execuție?

Răspuns scurt: Rulezi întâi smoke-ul, apoi cazurile cu risc mare (impact și probabilitate mari: funcționalități noi, zone modificate, fluxuri de bani), ținând cont de dependențe (login înaintea checkout-ului) și de disponibilitatea datelor și a mediului. Cazurile cu risc mic merg la final.

Ordinea de execuție urmărește un principiu: dacă ești oprit oricând, ce ai rulat până atunci trebuie să fie cel mai valoros. Criteriile, în ordinea în care le aplic:

  • smoke întâi: dacă build-ul e instabil, afli în 15 minute, nu după o zi;
  • riscul: fiecare caz are o prioritate din analiza de risc. Primele: funcționalitățile noi și modificate în acest release, zonele cu bani (plată, prețuri, rambursări), cerințele legale, zonele cu multe defecte în trecut;
  • dependențele tehnice și logice: dacă testele de retur au nevoie de o comandă livrată, rulez întâi testele care creează și livrează comanda și le refolosesc datele; un caz care setează configurația pentru alții merge primul;
  • resursele: cazurile care au nevoie de un dispozitiv anume, de un coleg din altă echipă sau de o fereastră de timp pe un mediu partajat se programează când resursa e disponibilă;
  • feedback rapid către developeri: zonele în care e probabil să găsesc defecte le rulez devreme, ca reparațiile să aibă timp să ajungă înapoi la mine.

Programa ISTQB numește asta prioritizare bazată pe risc, pe acoperire sau pe cerințe și spune explicit că dependențele pot impune o ordine diferită de prioritatea pură.

Ce comunic: înainte de execuție, lista cazurilor care probabil nu vor fi rulate, ca managerul să accepte riscul conștient sau să găsească ajutor. La final, raportul spune clar ce nu s-a rulat, nu doar procentul de Pass.

Ce urmărește intervievatorul: Verifică dacă îmbini riscul cu realitatea dependențelor și dacă știi să comunici ce rămâne netestat. Greșeala tipică este rularea în ordinea din document.

Greșeala, în practică:Cazuri lăsate NeexecutatRegresie fără prioritizare pe risc

43 Mid

În timpul execuției observi un comportament pe care cerința nu îl acoperă deloc. Nu știi dacă e corect sau nu. Cum marchezi testul și ce faci mai departe?

Răspuns scurt: Nu marchezi Fail sau Pass din reflex. Notezi exact ce ai observat, verifici alte oracole (versiunea veche, aplicații similare, criteriile de acceptare, colegii), apoi ridici o întrebare către Product Owner. Testul rămâne Blocked sau cu o notă, până la clarificare.

Situația apare des: cerința spune ce se întâmplă la plata reușită și la cea refuzată, dar nimic despre ce se întâmplă dacă utilizatorul închide fereastra în timpul redirecționării spre bancă.

Cum procedez:

  • notez precis comportamentul observat: pașii, datele, ce s-a întâmplat (comanda a rămas „În așteptare” două ore, fără email);
  • caut alte oracole: cum se comportă versiunea anterioară, ce zic criteriile de acceptare sau discuțiile din tichet, cum se comportă aplicații similare, ce ar aștepta în mod rezonabil un utilizator;
  • evaluez impactul: dacă ar fi greșit, cât de grav ar fi? Un comportament care pune în pericol bani sau date personale merită semnalat imediat;
  • ridic întrebarea către Product Owner sau analist, cu exemplul concret și, ideal, cu o propunere: „Propun: după 30 de minute fără răspuns de la bancă, comanda se anulează și stocul se eliberează. E corect?”
  • marchez testul potrivit regulilor echipei: de obicei Blocked sau Retest cu o notă de tipul „Așteaptă clarificare cerință, întrebare în SHOP-512”. Unele echipe deschid direct un defect cu tipul „Întrebare” sau „Clarificare”.

După răspuns, actualizez cerința sau criteriile de acceptare (sau cer actualizarea lor) și adaug un caz de test pentru situația respectivă. Altfel, următorul tester va ajunge la aceeași întrebare.

Ce nu fac: nu ignor comportamentul pentru că „nu e în cerință” și nu îl raportez ca bug critic fără să știu dacă e greșit.

Ce urmărește intervievatorul: Verifică judecata în zone gri, foarte frecvente în practică. Greșeala tipică este fie ignorarea, fie raportarea ca bug sigur.

Greșeala, în practică:Cerință ambiguă testată fără clarificare

44 Senior

Cum pregătești datele de test pentru un magazin online? Poți folosi o copie a bazei de date de producție pe mediul de test?

Răspuns scurt: Datele le creezi intenționat (conturi, produse, comenzi în stări diferite), prin interfață, API sau scripturi, și le documentezi. O copie de producție cu date personale nu se folosește așa cum e: GDPR cere minimizare și protecție, deci datele se anonimizează sau se generează sintetic.

Datele de test bune sunt cunoscute, reproductibile și suficient de variate. Pentru un magazin online pregătesc de obicei:

  • conturi pe roluri: client nou, client cu istoric bogat, client cu card de fidelitate, client blocat, administrator, operator de comenzi;
  • produse în situații diferite: în stoc, ultimul exemplar, fără stoc, la reducere, cu variante (mărime, culoare), cu nume lungi și cu diacritice;
  • comenzi în fiecare stare: nouă, plătită, expediată, livrată, anulată, returnată parțial;
  • cupoane active, expirate, consumate, cu prag minim;
  • carduri de test furnizate de procesatorul de plăți (Stripe, de exemplu, publică numere de card pentru reușită, refuz și autentificare 3D Secure).

Le creez prin API sau prin scripturi SQL, nu manual de fiecare dată, și le documentez într-un fișier pe care îl folosește toată echipa. Datele care se consumă (stoc, cupoane de unică folosință) trebuie să poată fi refăcute ușor.

Copia de producție: tentantă, pentru că are volume și cazuri reale, dar conține date personale (nume, adrese, telefoane, istoric de cumpărături). Regulamentul GDPR cere ca datele personale să fie folosite doar în scopul pentru care au fost colectate și protejate corespunzător, iar mediile de test au de obicei acces mai larg și securitate mai slabă. De aceea practica acceptată este anonimizarea sau pseudonimizarea înainte de copiere (nume, emailuri și telefoane înlocuite, păstrând formatul) sau generarea de date sintetice realiste. Decizia finală se ia împreună cu responsabilul de protecția datelor.

Ca tester, nu folosești niciodată date reale de card sau date ale clienților în tichete.

Ce urmărește intervievatorul: Verifică dacă tratezi datele de test ca pe un artefact de proiect și dacă știi de riscurile legale. Greșeala tipică este să spui că o copie de producție e soluția ideală.

Greșeala, în practică:Caz de test fără date de test concreteDate de test inexistente pe mediu

45 Senior

Intri într-un proiect cu 800 de cazuri de test manuale, scrise de-a lungul a trei ani, multe învechite. Regresia durează două săptămâni. Cum pui ordine?

Răspuns scurt: Măsori întâi (ce cazuri au mai găsit defecte, ce zone acoperă, care sunt duplicate sau învechite), apoi le legi de riscuri și de funcționalitățile actuale, elimini și comasezi, separi un nucleu de regresie prioritizat și muți spre automatizare ce se repetă.

Nu încep prin a șterge. Încep prin a înțelege ce am:

  • inventar: export din unealta de management al testelor, cu data ultimei modificări, data ultimei rulări, numărul de defecte găsite de fiecare caz, secțiunea, prioritatea;
  • harta acoperirii: pun cazurile față în față cu funcționalitățile actuale și cu riscurile; apar imediat zone supraacoperite (120 de cazuri pentru profilul utilizatorului) și zone neacoperite (plata nouă cu portofel digital);
  • clasificarea: fiecare caz intră într-o categorie: păstrat, actualizat, comasat cu altul, transformat în checklist, mutat spre automatizare, arhivat. Cazurile pentru funcționalități scoase din produs sau cele care nu au mai fost rulate de un an sunt candidați evidenți la arhivare.

Apoi construiesc structura nouă:

  • un nucleu de regresie prioritizat după risc, care se poate rula în 2–3 zile;
  • un set extins, rulat doar în zonele afectate de o schimbare, pe baza analizei de impact;
  • smoke și regresia stabilă automatizate, cu ajutorul unui inginer de automatizare;
  • sesiuni exploratorii planificate, care înlocuiesc zeci de cazuri detaliate cu risc mic.

Reguli ca problema să nu revină: fiecare caz nou e legat de o cerință, se revizuiește suita la fiecare release major, cazurile care nu mai sunt relevante se arhivează la închiderea story-ului.

Fac schimbarea pe etape și cu acordul echipei și al managerului, cu argumente măsurabile: timpul de regresie înainte și după și defectele scăpate în producție. Arhivez, nu șterg definitiv, ca să pot reveni.

Ce urmărește intervievatorul: Verifică dacă poți conduce o îmbunătățire de proces bazată pe date, fără să creezi risc. Răspunsul slab este fie „rulăm tot mai repede”, fie „ștergem jumătate”.

Greșeala, în practică:Cazuri de test duplicate

Raportarea defectelor

46 Junior

Cum arată un titlu bun pentru un raport de bug? Rescrie titlurile: „Nu merge coșul”, „Eroare la plată”, „Bug pe pagina de produs”.

Răspuns scurt: Un titlu bun spune ce nu merge, unde și în ce condiție, pe scurt, ca să poată fi înțeles din lista de tichete. Exemplu: „Coș: totalul nu se actualizează după modificarea cantității din pagina coșului”.

Titlul e partea din raport pe care o citesc cei mai mulți oameni, de obicei într-o listă, la triere sau în planificare. Trebuie să răspundă la trei întrebări: ce se întâmplă greșit, unde și în ce condiții. O formulă utilă: [Zonă] Acțiune/condiție → rezultat greșit.

Rescrierile, presupunând detaliile aflate la investigație:

  • „Nu merge coșul” → „Coș: totalul nu se recalculează după modificarea cantității din câmpul numeric (merge cu butoanele +/−)”;
  • „Eroare la plată” → „Checkout: plata cu card cu 3D Secure afișează «Eroare 500» după confirmarea în aplicația băncii, iar comanda rămâne neplătită”;
  • „Bug pe pagina de produs” → „Pagina produsului: prețul redus nu apare pentru produsele cu variante de mărime, se afișează prețul întreg”.

Reguli pe care le respect:

  • fără cuvinte vagi precum „nu merge”, „problemă”, „eroare” fără detaliu;
  • fără opinii sau emoție („iar s-a stricat...”);
  • fără severitate în titlu, pentru că ea are propriul câmp;
  • un singur defect per titlu;
  • termenii din aplicație, scriși la fel ca în interfață, ca titlul să poată fi găsit prin căutare;
  • dacă echipa lucrează în engleză, titlul e în engleză, chiar dacă discuția e în română.

Un test simplu: un developer care citește doar titlul ar trebui să știe ce zonă de cod să deschidă și să ghicească gravitatea.

Ce urmărește intervievatorul: Verifică dacă știi să sintetizezi un defect într-o frază utilă. Greșeala tipică este fie un titlu vag, fie un paragraf întreg în titlu.

Greșeala, în practică:Titlu de bug vag („Nu merge”)Titlu de bug prea lung

47 Junior

Ai observat că un cupon de reducere de 10% se poate aplica de două ori dacă apeși rapid de două ori pe „Aplică”. Scrie pașii de reproducere, rezultatul așteptat și rezultatul obținut.

Răspuns scurt: Pașii trebuie să plece de la o stare cunoscută, să fie numerotați, cu date concrete și cu un singur act per pas, iar rezultatul obținut descrie exact ce ai văzut, cu valori. Menționezi și frecvența (de câte ori ai reprodus).

Un exemplu de raport:

Titlu: Coș: cuponul TOAMNA10 se aplică de două ori la dublu click
       rapid pe „Aplică”, reducerea totală devine 20%

Mediu: test.exemplu.ro, build 2.14.3, Chrome 130, Windows 11
Precondiții: cont test.client1@exemplu.ro, coș gol,
             cupon TOAMNA10 (10%) activ și nefolosit

Pași de reproducere:
1. Loghează-te cu contul de mai sus
2. Adaugă în coș produsul „Cană albastră” (39,90 lei), cantitate 5
3. Deschide pagina Coș
4. Scrie TOAMNA10 în câmpul „Cod cupon”
5. Fă dublu click rapid pe butonul „Aplică”

Rezultat așteptat: cuponul se aplică o singură dată;
  reducere 19,95 lei, total 179,55 lei (fără livrare)
Rezultat obținut: apar două rânduri „TOAMNA10 −19,95 lei”;
  total 159,60 lei; reducerea se păstrează la checkout
Frecvență: 4 din 5 încercări; cu un singur click nu apare
Atașamente: video 12 s, captură Network cu cele două
  request-uri POST /api/cart/coupon, ambele cu status 200

Ce face pașii buni: pornesc de la o stare clară, au un singur act pe pas, folosesc date concrete, sunt minimi (am eliminat pașii care nu contau, de exemplu alegerea livrării). Frecvența e esențială la defectele dependente de timp. Captura din Network îi spune developerului imediat că serverul acceptă al doilea request, deci reparația nu se poate face doar în interfață.

Severitatea ar fi mare (pierdere de bani), indiferent de cât de ciudat pare dublu click-ul.

Ce urmărește intervievatorul: Verifică dacă scrii pași pe care un developer îi poate urma fără să te întrebe nimic. Greșeala tipică este omiterea frecvenței și a datelor exacte.

Greșeala, în practică:Bug fără pași de reproducere

48 Junior

Ce greșeli tipice vezi în secțiunile „rezultat așteptat” și „rezultat obținut” ale rapoartelor de bug? Dă exemple bune și rele.

Răspuns scurt: Greșeli tipice: rezultatul așteptat lipsește sau e „să meargă”, rezultatul obținut e o interpretare („calculul e greșit”) în loc de observație, lipsesc valorile exacte și sursa așteptării. Bine: valori concrete și trimitere la cerință.

Cele două câmpuri sunt nucleul raportului: diferența dintre ele este defectul. Greșelile frecvente:

  • rezultat așteptat lipsă sau vag: „Să funcționeze corect.” Developerul nu știe ce înseamnă „corect”.
  • interpretare în loc de observație: „Rezultat obținut: TVA-ul se calculează greșit.” Ce ai văzut, de fapt? Poate e o rotunjire, poate e altă cotă.
  • lipsa valorilor: „Totalul e greșit” în loc de „Totalul afișat: 118,99 lei”.
  • așteptare fără sursă: când așteptarea nu e evidentă, spune de unde vine (cerința, criteriul de acceptare, versiunea anterioară).
  • mai multe probleme amestecate în rezultatul obținut.
  • soluția în loc de așteptare: „Rezultat așteptat: developerul să schimbe rotunjirea în backend.”

Exemplu rău:

Așteptat: totalul corect
Obținut: totalul e greșit

Exemplu bun:

Așteptat: Total 119,00 lei (100,00 lei + TVA 19%, conform
  criteriului de acceptare 3 din SHOP-210)
Obținut: Total 118,99 lei; subtotal 100,00 lei, TVA 18,99 lei

În varianta bună, developerul vede imediat că problema e la calculul TVA-ului, probabil o rotunjire. Exemplul presupune cota de 19%; dacă testezi pe altă cotă, valorile se schimbă, de aceea cota trebuie scrisă explicit. Cu cât rezultatele sunt mai precise, cu atât mai puține mesaje schimbi cu developerul înainte de reparație.

Ce urmărește intervievatorul: Verifică dacă separi observația de interpretare. Greșeala tipică este scrierea rezultatului obținut ca diagnostic.

Greșeala, în practică:Fără rezultat așteptat vs obținutFail fără rezultat obținut și fără bug

49 Junior

Ce informații despre mediu și ce atașamente pui într-un raport de bug pentru o aplicație web? Dar pentru una mobilă?

Răspuns scurt: Web: URL-ul mediului, build-ul, browserul și versiunea, sistemul de operare, rezoluția, contul folosit, ora, plus capturi, video, erori din consolă și request-ul eșuat. Mobil: model, versiune de sistem, versiunea aplicației, tipul de rețea, plus video și loguri.

Developerul trebuie să poată reconstitui contextul exact. Multe bug-uri închise ca „nu se reproduce” au fost de fapt reale, doar pe alt mediu.

Pentru o aplicație web:

  • mediul (test, staging, producție) și URL-ul exact al paginii;
  • versiunea build-ului sau a release-ului (des afișată în subsolul aplicației sau într-un endpoint de versiune);
  • browserul și versiunea (Chrome 130, Safari 18), sistemul de operare, rezoluția sau dimensiunea ferestrei, zoom-ul, dacă e relevant;
  • extensii care pot influența (blocante de reclame), modul incognito sau nu;
  • contul și rolul, limba interfeței, ora cu fusul orar;
  • atașamente: captură cu zona marcată, video pentru fluxuri, erorile din Console, request-ul și răspunsul relevant din Network (status, corp), eventual un fișier HAR, ID-ul comenzii sau al tranzacției.

Pentru o aplicație mobilă:

  • modelul dispozitivului, versiunea de Android sau iOS, dacă e emulator sau dispozitiv real;
  • versiunea aplicației și numărul de build, sursa instalării (TestFlight, Google Play testare internă, APK);
  • rețeaua (Wi-Fi, date mobile, slabă), orientarea ecranului, limba și setările relevante (mod întunecat, dimensiunea fontului);
  • atașamente: înregistrarea ecranului (ambele platforme o au în sistem), loguri (logcat pentru Android, Console pentru iOS) dacă ai acces, ora exactă.

Regula practică: completează mediul chiar dacă pare evident; un raport rămâne în sistem luni de zile, iar „pe ultimul build” nu mai înseamnă nimic după o săptămână.

Ce urmărește intervievatorul: Verifică dacă dai contextul necesar pentru reproducere. Greșeala tipică este omiterea versiunii build-ului și a browserului.

Greșeala, în practică:Raport fără mediu de testRaport fără captură de ecran

50 Junior

Stabilește severitatea pentru fiecare dintre aceste defecte dintr-un magazin online și justifică: a) aplicația se blochează la plata cu card; b) logo-ul are altă nuanță de albastru; c) filtrul de preț ignoră produsele la reducere; d) o greșeală de scriere în textul butonului „Cumpără”; e) rapoartele lunare din administrare se generează în 3 minute în loc de 30 de secunde.

Răspuns scurt: a) critică: blochează fluxul principal și pierde bani; c) majoră: rezultate greșite, cu ocolire posibilă; e) medie sau minoră, în funcție de cât de des se folosesc; b) și d) minore (cosmetice), deși d) poate primi prioritate mare pentru că e foarte vizibilă.

Severitatea descrie impactul tehnic și funcțional al defectului asupra sistemului; prioritatea, cât de repede trebuie reparat. Scara uzuală: critică (blocantă), majoră, medie, minoră, cosmetică; fiecare echipă își definește scara, iar eu o folosesc pe cea a proiectului.

  • a) Blocare la plata cu card: critică. Fluxul principal nu poate fi finalizat, clienții nu pot plăti, pierderea e directă. Prioritate maximă, posibil hotfix.
  • c) Filtrul de preț ignoră produsele la reducere: majoră. Funcționalitatea dă rezultate incorecte, clienții nu găsesc exact produsele cu ofertă, dar pot ajunge la ele altfel (navigare, căutare). Dacă tocmai începe o campanie de reduceri, prioritatea crește.
  • e) Rapoarte lente: medie sau minoră. Funcția merge, doar mai încet. Dacă raportul e folosit o dată pe lună de doi oameni, impactul e mic; dacă contabilitatea îl rulează de zeci de ori pe zi, devine major. Aș întreba de frecvența de folosire.
  • b) Nuanța logo-ului: cosmetică. Nu afectează funcționarea. Prioritatea poate fi totuși ridicată dacă există o cerință strictă de identitate vizuală.
  • d) Greșeală pe butonul „Cumpără”: minoră ca severitate, dar cu prioritate mare: e pe fiecare pagină de produs, afectează încrederea, iar reparația durează câteva minute. E exemplul clasic de severitate mică cu prioritate mare.

Ideea principală: severitatea o propune testerul pe baza impactului; prioritatea se decide de obicei cu Product Owner-ul, care vede contextul de business.

Ce urmărește intervievatorul: Verifică aplicarea practică a celor două concepte și justificarea, nu doar etichetele. Greșeala tipică este să dai aceeași valoare severității și priorității la fiecare defect.

Greșeala, în practică:Severitate confundată cu prioritateaToate bug-urile marcate Critice

51 Junior

La trierea bug-urilor apar rezoluțiile Rejected, Duplicate, Deferred, Won't Fix și Cannot Reproduce. Ce înseamnă fiecare și ce faci ca tester când bug-ul tău primește una dintre ele?

Răspuns scurt: Rejected: nu e defect (comportament corect sau cerință greșit înțeleasă). Duplicate: există deja raportat. Deferred: e real, dar se repară mai târziu. Won't Fix: e real, dar nu se va repara. Cannot Reproduce: nu a putut fi reprodus. Răspunzi cu date noi, nu cu insistență.

Trierea este momentul în care echipa (de obicei Product Owner-ul, un developer și testerul) decide ce se întâmplă cu fiecare raport. Rezoluțiile frecvente, cu ce fac eu:

  • Rejected / Not a Bug: comportamentul e conform cerinței. Recitesc cerința; dacă am înțeles-o greșit, accept și corectez cazul de test. Dacă cerința însăși mi se pare greșită pentru utilizator, propun o îmbunătățire separată, cu argumente.
  • Duplicate: verific dacă e într-adevăr același defect (aceeași cauză, nu doar același simptom). Adaug în tichetul original informațiile noi pe care le am (alt browser, alți pași). Data viitoare caut înainte de a raporta.
  • Deferred / Postponed: defectul e real, dar se repară într-un release viitor. Mă asigur că riscul e cunoscut și documentat (de exemplu, în notele de release) și că tichetul e planificat, nu uitat.
  • Won't Fix: defectul e real, dar costul reparării e mai mare decât beneficiul (funcționalitate retrasă curând, impact neglijabil). Accept, dar cer să fie notat; dacă impactul crește, îl redeschid cu dovezi.
  • Cannot Reproduce / Works for Me: încerc din nou pe build-ul curent, compar mediile (browser, cont, date, ordinea pașilor), adaug video și loguri. Dacă nu mai pot reproduce nici eu, îl închid, dar îl țin sub observație.

Cheia: discuția e despre produs, nu despre cine are dreptate. Câștigi credibilitate când revii cu date noi, nu când insiști.

Ce urmărește intervievatorul: Verifică dacă știi ciclul de viață dincolo de Nou și Rezolvat și cum reacționezi profesionist. Greșeala tipică este să tratezi orice respingere ca pe un atac personal.

Greșeala, în practică:Bug duplicat raportat din nouRespins în loc de Amânat

52 Junior

Developerul marchează bug-ul tău ca „Resolved”. Cum îl retestezi? Când îl redeschizi și când deschizi un bug nou?

Răspuns scurt: Verifici întâi că reparația e pe build-ul instalat, apoi repeți exact pașii din raport și câteva variații apropiate, plus o regresie scurtă în zonă. Redeschizi dacă apare același defect; deschizi unul nou dacă e o problemă diferită, chiar apărută după reparație.

Pașii mei la retestare (testarea de confirmare):

  • verific build-ul: reparația e într-adevăr pe mediul de test? Mă uit la versiunea afișată și la tichet (numărul build-ului sau commitul menționat). Multe redeschideri false vin din testarea pe build-ul vechi;
  • repet exact pașii din raport, cu aceleași date sau cu date echivalente, dacă cele vechi s-au consumat;
  • încerc variații apropiate: alt browser, altă valoare de aceeași clasă, alt rol de utilizator. Reparațiile rezolvă des doar cazul raportat;
  • regresie scurtă în zona modificată, pentru că o reparație poate strica altceva;
  • dacă trece, marchez Verified sau Closed (după fluxul echipei), cu build-ul pe care am verificat.

Când redeschid (Reopened): același defect apare din nou, cu aceiași pași sau cu o variație care arată că reparația e incompletă. Adaug un comentariu cu build-ul, ce am încercat și ce am obținut acum, eventual video nou.

Când deschid un bug nou:

  • problema e diferită, chiar dacă e în aceeași zonă;
  • e o regresie introdusă de reparație (de exemplu, butonul merge acum, dar pe mobil a dispărut); îl leg de tichetul original cu o relație de tipul „cauzat de”;
  • tichetul original e închis de mult timp și a fost livrat; în multe echipe, defectele din release-uri vechi nu se redeschid.

Motivul pentru separare: un tichet trebuie să aibă un singur istoric clar, ca metricile și notele de release să rămână corecte.

Ce urmărește intervievatorul: Verifică dacă înțelegi retestarea corect și disciplina tichetelor. Greșeala tipică este redeschiderea pentru orice problemă nouă din aceeași pagină.

Greșeala, în practică:Bug închis fără retestareBug închis deși problema încă apare

53 Mid

Echipa lucrează în engleză. Scrie un raport de bug în engleză pentru următoarea situație: pe pagina de checkout, pe iPhone, câmpul „Cod poștal” acceptă doar 5 cifre, iar codurile poștale românești au 6 cifre.

Răspuns scurt: Titlu clar în engleză, pași numerotați la imperativ, expected și actual cu valori concrete, mediu complet. Limbajul e simplu și neutru, fără expresii ambigue, cu termenii din interfață în ghilimele.

Un exemplu de raport:

Title: Checkout (iOS Safari): Postal code field accepts max 5
digits, Romanian postal codes (6 digits) cannot be entered

Environment: staging.example.ro, build 3.2.0
Device: iPhone 15, iOS 18.1, Safari
Account: test.client2@example.ro (Romanian address)

Preconditions: product "Blue mug" in cart, user logged in

Steps to reproduce:
1. Go to Cart and tap "Checkout"
2. Select "Romania" in "Country"
3. Tap "Postal code" and type 010011
4. Tap "Continue"

Expected result: "010011" is accepted (Romanian postal codes
have 6 digits) and the user goes to the delivery step.
Actual result: Only "01001" is kept; the 6th digit is ignored.
After tapping "Continue", the error "Invalid postal code" is shown.

Frequency: 5/5
Notes: Same behavior on Chrome Android 14. Desktop Chrome
accepts 6 digits. Looks like a mobile-only maxlength=5.
Severity: Major (blocks checkout for Romanian addresses on mobile)
Attachments: screen recording, screenshot of the error

Sfaturi de limbaj: imperativ simplu în pași („Tap”, „Go to”, „Select”), „Expected/Actual result” ca etichete standard, fără „it doesn't work”. Ipoteza despre cauză e marcată clar ca ipoteză („Looks like”) și pusă la note, nu în rezultatul obținut. Am verificat și pe Android și desktop, ca să delimitez problema; asta economisește timpul developerului. Severitatea e majoră, nu critică, doar dacă există o altă cale (de exemplu, desktop); pentru majoritatea clienților de pe mobil e de fapt blocantă, iar asta se discută la triere.

Ce urmărește intervievatorul: Verifică engleza profesională și structura raportului într-un context internațional. Greșeala tipică este traducerea literală din română sau amestecul limbilor.

54 Mid

Găsești un defect într-o funcționalitate veche, care nu a fost modificată în acest sprint. Cum stabilești dacă este o regresie și de ce contează?

Răspuns scurt: Verifici dacă defectul apare și pe versiunea anterioară (producție sau un build vechi). Dacă acolo funcționa, e regresie introdusă recent și poate bloca release-ul. Dacă apărea și înainte, e un defect vechi, cu altă prioritate.

O regresie înseamnă că ceva care funcționa nu mai funcționează după o schimbare. Distincția schimbă discuția: o regresie e aproape mereu un motiv să nu lansezi versiunea nouă, pe când un defect vechi, existent deja în producție, se prioritizează normal.

Cum verific:

  • compar cu producția (dacă se poate testa fără efecte reale) sau cu un mediu pe care rulează încă versiunea anterioară;
  • dacă există, instalez un build vechi (pe mobil e simplu: versiunea anterioară din TestFlight sau un APK vechi);
  • mă uit în istoricul testelor: cazul de test a trecut la ultimul release? Pe ce build?
  • caut în tichetele vechi: poate e deja raportat.

Dacă e regresie, ajut la localizare: ce s-a schimbat în această versiune? Uneori defectul apare într-o zonă nemodificată pentru că s-a schimbat o componentă comună (o bibliotecă actualizată, un serviciu partajat, o configurare). Dacă există mai multe build-uri intermediare pe care le pot testa, restrâng intervalul: „merge în 2.13.1, nu merge în 2.13.4”. Developerul poate apoi găsi rapid commitul, de exemplu cu git bisect.

În raport scriu explicit: „Regresie: funcționează în 2.12 (producție), nu funcționează în 2.13.4 (staging)” și adaug eticheta folosită de echipă, de obicei regression. Severitatea rămâne cea dată de impact, dar prioritatea crește aproape mereu.

Apoi propun un caz de regresie pentru zona respectivă, dacă nu exista.

Ce urmărește intervievatorul: Verifică dacă știi să faci investigație dincolo de raportare și să influențezi decizia de release. Greșeala tipică este să nu menționezi deloc dacă e regresie.

55 Mid

Când raportezi mai multe probleme într-un singur tichet și când le separi? Exemplu: pe pagina de profil găsești o eroare la salvarea telefonului, două greșeli de scriere și o aliniere greșită pe mobil.

Răspuns scurt: Regula: un tichet, un defect. Separi problemele care pot fi reparate, testate și prioritizate independent. Excepția acceptată des: probleme cosmetice mărunte din aceeași pagină, grupate într-un singur tichet, dacă echipa e de acord.

În exemplu aș face trei tichete:

  • eroarea la salvarea telefonului: tichet separat, severitate mai mare, poate implica backendul;
  • alinierea pe mobil: tichet separat, e altă cauză (CSS), probabil alt developer și altă prioritate;
  • cele două greșeli de scriere: un singur tichet „Texte greșite pe pagina de profil”, cu ambele listate, dacă echipa acceptă gruparea cosmeticelor.

De ce separ:

  • ciclul de viață: dacă un tichet are trei probleme și două sunt reparate, ce status are? Tichetul nu se poate închide, iar raportarea devine neclară;
  • prioritizarea: problemele au severități diferite; amestecate, cea gravă poate fi amânată împreună cu cele minore;
  • alocarea: pot fi reparate de oameni diferiți (frontend, backend);
  • metricile și istoricul: numărul de defecte și timpul de reparație au sens doar dacă un tichet înseamnă un defect;
  • retestarea: e clar ce verifici.

Când grupez: mai multe greșeli de text pe aceeași pagină sau în același email, probleme vizuale mici din același ecran, reparabile împreună în câteva minute. Le pun ca listă numerotată, cu capturi pentru fiecare.

Când e un singur defect cu mai multe simptome (de exemplu, aceeași cauză produce eroare și pe pagina de profil, și în aplicația mobilă), fac un singur tichet și listez toate locurile afectate. Dacă nu știu dacă au aceeași cauză, le raportez separat și le leg între ele.

Ce urmărește intervievatorul: Verifică disciplina de raportare și înțelegerea efectului tichetelor amestecate. Greșeala tipică este un tichet-ciorchine de tip „probleme pagina de profil”.

Greșeala, în practică:Mai multe bug-uri într-un raportBug redeschis pentru altă problemă

56 Mid

Testezi o funcționalitate nouă de checkout și observi, în treacăt, un defect în pagina de blog, care nu ține de sprintul tău. Ce faci?

Răspuns scurt: Îl raportezi oricum, separat, pentru zona respectivă, cu aceeași calitate a raportului, dar nu îți schimbi focusul: nu îl investighezi pe larg în timpul alocat checkout-ului. Îl semnalezi celui responsabil și lași prioritatea la triere.

Un tester care tace despre un defect pentru că „nu e în scopul meu” lasă produsul mai slab. Pe de altă parte, sprintul are obiective, iar timpul petrecut în altă zonă vine din timpul de checkout. Echilibrul:

  • notez imediat ce am observat (pașii, captura, URL-ul, build-ul), ca să nu pierd informația;
  • verific rapid dacă nu e deja raportat;
  • raportez defectul ca tichet separat, în proiectul sau componenta potrivită (de exemplu, componenta „Blog”), cu o investigație minimă: atât cât să fie reproductibil. Nu îl leg de story-ul de checkout, ca să nu îl blocheze;
  • anunț pe cine trebuie: Product Owner-ul sau echipa care deține zona, mai ales dacă e grav (de exemplu, blogul expune emailurile abonaților);
  • mă întorc la checkout. Prioritatea defectului din blog o decide trierea, nu eu.

Dacă e foarte grav (securitate, date personale, producție afectată), escaladez imediat, indiferent de sprint, pe canalul stabilit pentru incidente.

Ce evit: să îl investighez o oră pentru că e interesant, să îl raportez doar pe chat (se pierde), să îl pun în tichetul de checkout.

Un tester bun e și un bun observator al întregului produs. Mulți manageri apreciază explicit raportările din afara scopului, cu condiția să nu afecteze angajamentele sprintului.

Ce urmărește intervievatorul: Verifică responsabilitatea pentru întregul produs, echilibrată cu focusul pe sprint. Greșeala tipică este fie ignorarea, fie abandonarea sarcinii proprii.

Greșeala, în practică:Bug din afara cazului neraportat

57 Senior

Ai 140 de bug-uri deschise înainte de un release, iar echipa nu le poate repara pe toate. Cum organizezi o sesiune de triere eficientă?

Răspuns scurt: Pregătești lista dinainte (deduplicată, completă, grupată pe zone și severitate), stabilești cine decide (PO, tech lead, QA), timpul și criteriile de decizie, treci rapid prin cele critice și majore, iar pentru fiecare decizi: repară acum, amână, nu repara sau mai investighează.

O triere fără pregătire devine o ședință de trei ore în care se discută primele 15 tichete. Cum aș organiza-o:

Înainte:

  • curăț lista: duplicate închise, tichete incomplete trimise înapoi autorilor, bug-uri vechi verificate pe build-ul curent (unele nu se mai reproduc);
  • verific că fiecare tichet are severitate, componentă și versiune;
  • grupez pe zone și pe severitate; marchez regresiile și bug-urile raportate de clienți;
  • trimit lista participanților cu o zi înainte.

Participanți: Product Owner-ul (decide prioritatea de business), tech lead-ul (estimează efortul și riscul reparației), QA (impactul și riscul calității), eventual suportul pentru clienți.

Criterii convenite dinainte, de exemplu:

  • critice și regresiile: se repară obligatoriu înainte de release;
  • majore: se repară dacă efortul e mic sau dacă afectează fluxuri principale;
  • medii și minore: se planifică în următoarele sprinturi sau primesc Won't Fix;
  • orice decizie de amânare a unui defect major este scrisă și acceptată de PO.

În timpul sesiunii: timebox de 2–3 minute pe tichet; cele care cer investigație ies din discuție cu un responsabil și un termen. Decizia se scrie direct în tichet (prioritate, versiune țintă, rezoluție).

După: comunic rezumatul (ce intră în release, ce riscuri se acceptă), actualizez notele de release cu problemele cunoscute și planific retestarea. Dacă trierea scoate la iveală 140 de bug-uri înainte de release, ridic în retrospectivă și problema de proces: de ce se adună atâtea atât de târziu?

Ce urmărește intervievatorul: Întrebarea de senior verifică dacă poți facilita decizii cu mai mulți participanți și cu criterii clare. Răspunsul slab descrie doar etichetarea severităților.

Greșeala, în practică:Toate bug-urile marcate CriticeBug fără severitate și prioritate

Planificare, risc și raportare

Exersează capitolul cu exerciții reale: Curs testare manuală pentru începători →
58 Junior

Ce înseamnă „în scop” și „în afara scopului” într-un plan de testare? De ce e important să scrii explicit ce nu testezi?

Răspuns scurt: Scopul spune ce funcționalități, platforme și tipuri de testare acoperi; „în afara scopului” spune ce nu acoperi și de ce. Scris explicit, previne așteptările greșite, arată riscurile acceptate și te protejează când apare un defect în zona netestată.

Secțiunea de scop este, în practică, cea mai citită parte dintr-un plan de testare, pentru că stabilește așteptările.

În scop pentru un release cu checkout nou ar putea fi:

  • fluxul de checkout complet, pentru clienți logați și vizitatori;
  • metodele de plată card și ramburs;
  • Chrome, Safari, Firefox și Edge pe desktop, Safari pe iOS 17–18, Chrome pe Android 13–15;
  • testare funcțională, de regresie pe coș și cont, de compatibilitate și o verificare de accesibilitate pe pașii de checkout.

În afara scopului, cu motivul:

  • plata prin transfer bancar: nu se modifică în acest release;
  • testarea de încărcare: o face echipa de infrastructură separat;
  • panoul de administrare: nemodificat, acoperit doar de smoke;
  • browserele mai vechi decât ultimele două versiuni majore, conform politicii produsului.

De ce contează să scrii ce nu testezi:

  • așteptări aliniate: managerul și clientul nu presupun că „QA a testat tot”;
  • risc vizibil: fiecare excludere e un risc acceptat conștient de cineva, nu o omisiune;
  • negociere: lista e baza discuției când apare presiune pe timp („putem scoate Firefox din scop?”);
  • istoric: când apare un defect în producție într-o zonă exclusă, discuția e despre decizie, nu despre vină.

Scopul se revizuiește când se schimbă cerințele. Dacă apare o funcționalitate nouă în ultimul moment, o adaug explicit în scop sau în afara lui, nu o las neclar.

Ce urmărește intervievatorul: Verifică dacă știi să gestionezi așteptările prin documentare. Greșeala tipică este un plan care descrie doar ce se testează.

Greșeala, în practică:Plan fără „În afara scopului”

59 Junior

Ce medii folosește de obicei o echipă (dezvoltare, test, staging, producție)? De ce nu testezi direct în producție și ce poți totuși verifica acolo?

Răspuns scurt: Dezvoltarea e pentru developeri, testul pentru QA, staging-ul e o copie cât mai apropiată de producție pentru verificarea finală, iar producția e pentru utilizatori. În producție nu testezi liber, ca să nu afectezi clienți și date reale; acolo faci doar smoke controlat.

O configurație tipică:

  • dezvoltare (local sau dev): unde developerii scriu și rulează codul; instabil, se schimbă des;
  • test (QA): primește build-uri în mod regulat; aici rulează testarea funcțională și de regresie, cu date de test controlate;
  • staging (pre-producție): cât mai apropiat de producție ca infrastructură, configurare, integrări și volum de date; aici se face verificarea finală înainte de release, uneori și UAT;
  • producție: mediul real al utilizatorilor.

De ce nu testezi în producție ca în mediul de test:

  • efecte reale: o comandă de test pleacă la depozit, o plată se încasează, un email ajunge la un client real;
  • date reale: poți modifica sau vedea date personale ale clienților;
  • statistici poluate: rapoartele de vânzări, analytics și campaniile de marketing includ datele tale;
  • risc pentru disponibilitate: un test agresiv poate încetini site-ul.

Ce se face totuși în producție, controlat:

  • smoke după deploy: navigare, login cu un cont intern de test, căutare, adăugare în coș fără plată sau cu un produs intern de test;
  • verificarea configurărilor: certificatul HTTPS, redirecționările, integrarea cu analytics;
  • monitorizare și testare „shift-right”: urmărirea erorilor, feature flags pornite doar pentru echipă, lansări graduale.

Diferențele dintre medii (altă versiune de bază de date, alte chei de configurare, date mai puține pe test) explică multe defecte „care apar doar în producție”. De aceea în planul de testare scriu explicit pe ce mediu se face fiecare tip de testare.

Ce urmărește intervievatorul: Verifică înțelegerea elementară a infrastructurii de lucru. Greșeala tipică este fie „nu atingem niciodată producția”, fie testarea fără grijă acolo.

Greșeala, în practică:Testare pe producție din greșealăPlan de test fără mediul de testare

60 Mid

Scrie criterii de intrare și de ieșire concrete pentru testarea de sistem a unui checkout nou, înainte de lansare.

Răspuns scurt: Intrare: build-ul instalat pe test, smoke trecut, story-urile complete cu criterii de acceptare, date și conturi de test pregătite, procesatorul de plăți în modul test configurat. Ieșire: cazurile planificate rulate, zero defecte critice și majore deschise, riscurile mari acoperite, defectele rămase acceptate de PO.

Criteriile sunt utile doar dacă sunt măsurabile. Pentru checkout aș propune:

Criterii de intrare (când începem testarea de sistem):

  • build-ul cu toate story-urile de checkout e instalat pe mediul de test, cu versiunea notată;
  • smoke testul a trecut (pagina se încarcă, se poate plăti cu un card de test);
  • story-urile au criterii de acceptare aprobate de Product Owner;
  • testele unitare și de integrare ale developerilor trec în pipeline;
  • conturile, produsele și cupoanele de test sunt create; cheile de test pentru procesatorul de plăți sunt configurate;
  • defectele critice cunoscute din build-ul anterior sunt reparate.

Criterii de ieșire (când considerăm testarea încheiată):

  • 100% din cazurile cu prioritate critică și înaltă au fost rulate, iar cel puțin 95% din toate cazurile planificate (cifra se convine în echipă);
  • zero defecte critice și zero majore deschise în checkout; defectele medii rămase sunt evaluate și acceptate în scris de PO;
  • fiecare criteriu de acceptare are cel puțin un test trecut;
  • fluxurile de plată au fost testate pe toate browserele din scop, inclusiv cu 3D Secure și cu card refuzat;
  • regresia pe coș și cont a trecut;
  • raportul de finalizare e trimis.

Două observații: criteriile se stabilesc la planificare, nu în ziua release-ului, și nu sunt un contract rigid. Dacă nu sunt îndeplinite, testerul nu blochează singur lansarea, ci prezintă situația, iar decizia de a lansa cu risc acceptat o iau cei responsabili, în scris.

Ce urmărește intervievatorul: Verifică dacă poți transforma un concept teoretic în criterii verificabile. Greșeala tipică este „testarea e gata când nu mai sunt bug-uri”.

Greșeala, în practică:Plan de test fără criterii de ieșirePlan fără criterii de intrare

61 Mid

Cum faci analiza de risc pentru un checkout nou? Construiește o matrice simplă de risc și arată cum influențează testarea.

Răspuns scurt: Listezi riscurile de produs, estimezi pentru fiecare probabilitatea și impactul (de exemplu pe o scară 1–3), înmulțești, apoi aloci efortul de testare după scor: riscurile mari primesc testare mai profundă, mai devreme și cu mai multe tehnici.

Testarea bazată pe risc folosește riscul ca să decidă ce, cât, când și cât de profund testezi. Nivelul de risc se estimează din probabilitate (cât de probabil e să apară defectul: cod nou, complex, echipă nouă, integrare externă) și impact (cât de grav ar fi: bani, date, imagine, număr de clienți afectați).

Matrice simplă pentru checkout, pe scară 1–3:

Risc                                     Prob. Impact Scor
Plata se încasează, comanda nu apare       2     3     6
Calcul greșit al TVA sau al reducerii      2     3     6
Card refuzat tratat greșit                 2     2     4
3D Secure eșuează pe Safari iOS            2     3     6
Adresa cu diacritice se salvează greșit    2     2     4
Text greșit în emailul de confirmare       2     1     2
Lentoare la peste 50 de produse în coș     1     2     2

Cum influențează testarea:

  • scor 6: testare cât mai devreme, tehnici formale (tabele de decizie pentru reduceri, tranziții de stare pentru statusul plății), teste negative, pe mai multe browsere, eventual recenzie a codului sau a designului cu developerii, plus regresie automată;
  • scor 4: cazuri de test scriptate pe drumurile principale și pe câteva negative;
  • scor 2: checklist sau sesiune exploratorie scurtă.

Riscurile se revizuiesc pe parcurs: dacă găsesc multe defecte într-o zonă, probabilitatea crește. Analiza se face cu echipa, nu singur: developerii știu unde e codul fragil, Product Owner-ul știe impactul de business. Raportul final se poate formula pe riscuri: ce riscuri au fost reduse și ce risc rămâne.

Ce urmărește intervievatorul: Verifică dacă poți aplica testarea bazată pe risc, nu doar s-o definești. Greșeala tipică este o matrice în care totul are scor maxim.

Greșeala, în practică:Plan de test fără riscuriRegresie fără prioritizare pe risc

62 Mid

Ce conține un raport de progres al testării și prin ce diferă de raportul de finalizare? Cum arată un raport de progres util pentru un manager?

Răspuns scurt: Raportul de progres e periodic, în timpul testării: ce s-a rulat, ce defecte sunt deschise, ce blocaje și riscuri apar, ce urmează. Raportul de finalizare vine la final: rezumatul rezultatelor, criteriile de ieșire atinse, riscurile rămase, lecțiile învățate, recomandarea.

Raportul de progres (test progress report) servește controlului: arată dacă testarea merge conform planului și ce trebuie corectat. Se trimite periodic (zilnic sau săptămânal) sau la cerere. Raportul de finalizare (test completion report) închide o etapă sau un release și servește deciziei și învățării.

Un raport de progres util pentru un manager încape pe o pagină:

Release 3.2 - Checkout | Raport ziua 4 din 7
Stare generală: risc mediu (în urmă cu o zi)
Execuție: 86 din 120 de cazuri rulate; 74 Pass, 8 Fail, 4 Blocked
Defecte deschise: 1 critic, 3 majore, 6 minore
  Critic: SHOP-588 plata 3D Secure eșuează pe Safari iOS
Blocaje: 4 teste de ramburs blocate - mediul de curierat
  e indisponibil din ziua 3
Riscuri: dacă SHOP-588 nu e reparat până joi,
  testarea pe iOS nu se termină la timp
Ce urmează: regresie coș și cont, retestare SHOP-588
Ce cer: o zi de mediu de curierat funcțional

Ce face raportul util: începe cu concluzia, spune ce înseamnă cifrele (nu doar procente), numește defectele care contează, arată blocajele și cere acțiuni concrete.

Raportul de finalizare include: ce s-a testat față de plan și abaterile, rezultatele finale, gradul de îndeplinire a criteriilor de ieșire, defectele rămase și riscurile acceptate, recomandarea (lansare, lansare cu condiții, amânare) și lecțiile învățate pentru proiectele următoare.

Ce urmărește intervievatorul: Verifică dacă știi să comunici către management, nu doar să produci cifre. Greșeala tipică este un raport care conține doar numere fără interpretare.

63 Mid

Cum estimezi efortul de testare pentru o funcționalitate nouă? Ce tehnici de estimare cunoști?

Răspuns scurt: Spargi munca în activități (analiză, scriere cazuri, pregătire date și mediu, execuție, retestare, raportare), estimezi fiecare pe baza experienței sau a datelor istorice, adaugi rezervă pentru retestare și blocaje și validezi estimarea cu echipa (de exemplu, Planning Poker).

Tehnicile descrise de programa ISTQB se împart în două familii:

  • bazate pe metrici: folosesc date din proiecte anterioare. De exemplu, raportul dintre efortul de dezvoltare și cel de testare din proiectele similare, numărul mediu de cazuri pe story și timpul mediu de rulare, sau extrapolarea din primele zile de execuție;
  • bazate pe expertiză: oameni cu experiență estimează. Variante: Wideband Delphi (fiecare estimează separat, se discută diferențele, se reia), Planning Poker (varianta Agile, cu cărți), estimarea în trei puncte.

Estimarea în trei puncte, pentru o activitate:

E = (optimist + 4 * cel mai probabil + pesimist) / 6
Exemplu: (2 + 4*4 + 9) / 6 = 4,5 zile

Cum lucrez concret:

  • descompun în activități: lectura cerințelor și întrebări, scrierea cazurilor, pregătirea datelor și a mediului, execuția pe browserele din scop, raportarea, retestarea și regresia (cea mai des uitată), rapoartele;
  • estimez fiecare activitate, nu totalul dintr-o privire;
  • adaug riscuri explicite: integrare externă instabilă, cerințe neclare, primul contact cu domeniul;
  • compar cu funcționalități similare din trecut;
  • prezint estimarea cu presupunerile ei („presupune că mediul de plăți e disponibil din prima zi”).

Factorii care cresc efortul: calitatea slabă a cerințelor, complexitatea, numărul de platforme, nivelul de documentare cerut, stabilitatea build-urilor. Estimarea se revizuiește când se schimbă presupunerile.

Ce urmărește intervievatorul: Verifică dacă știi să estimezi structurat și să incluzi retestarea. Greșeala tipică este o cifră dată din instinct, fără presupuneri.

64 Senior

Care este diferența dintre o strategie de testare și un plan de testare? Ai nevoie de amândouă într-o echipă Agile?

Răspuns scurt: Strategia descrie abordarea generală a testării la nivel de produs sau organizație (niveluri, tipuri, automatizare, medii, criterii, unelte) și se schimbă rar. Planul aplică strategia la un proiect sau release concret (scop, calendar, resurse, riscuri). În Agile, ambele există, dar în forme mai ușoare.

Strategia de testare răspunde la „cum testăm, în general, în acest produs sau în această organizație?”. Conține, de obicei:

  • nivelurile de testare și cine le deține (developerii pentru unitare și integrare, QA pentru sistem, business pentru acceptanță);
  • tipurile de testare obligatorii (regresie, accesibilitate, securitate de bază) și cele contextuale;
  • abordarea automatizării: ce se automatizează, la ce nivel, cum intră în pipeline;
  • mediile și gestionarea datelor de test;
  • standardele de documentare și uneltele (Jira, TestRail);
  • definițiile comune: severitate, prioritate, criterii generale de ieșire.

Planul de testare răspunde la „cum testăm acest release sau proiect?”: scopul și excluderile, riscurile specifice, abordarea pentru fiecare risc, calendarul, oamenii, mediile, criteriile de intrare și de ieșire concrete, livrabilele.

Relația e de la general la particular: planul se abate de la strategie doar justificat și explicit.

În Agile ai nevoie de amândouă, dar în altă formă:

  • strategia poate fi un document scurt și viu (o pagină în Confluence) pe care echipa îl revizuiește periodic, plus Definition of Done;
  • planul nu mai e un document de 40 de pagini per proiect, ci se distribuie: o pagină de planificare pe release sau epic, criteriile de acceptare pe story, decizia despre ce se testează în fiecare sprint.

Ce nu dispare: deciziile despre scop, risc și criterii. Dacă nu sunt scrise nicăieri, sunt luate implicit, iar fiecare membru al echipei are altă variantă în minte.

Ce urmărește intervievatorul: Verifică dacă înțelegi nivelurile de documentare și le poți adapta. Greșeala tipică este să spui că în Agile nu există planificare a testării.

65 Senior

Care este diferența dintre riscurile de proiect și riscurile de produs? Dă exemple pentru fiecare și spune cum le gestionezi.

Răspuns scurt: Riscurile de produs țin de calitatea sistemului (calcul greșit, date expuse, lentoare) și se reduc prin testare. Riscurile de proiect țin de organizarea muncii (mediu indisponibil, oameni plecați, cerințe întârziate) și se gestionează prin planificare și escaladare.

Riscurile de produs (de calitate) sunt posibilitatea ca sistemul livrat să nu satisfacă nevoile utilizatorilor sau să producă pagube. Exemple:

  • calculul TVA greșit pe anumite produse;
  • datele personale ale clienților accesibile altor utilizatori;
  • checkout-ul cedează la vârfurile de trafic de Black Friday;
  • aplicația nu e utilizabilă cu cititoare de ecran, deși e obligatoriu legal.

Le gestionezi prin testare și alte măsuri de calitate: identificare, evaluare (probabilitate și impact), alegerea tehnicilor și a profunzimii testării, recenzii, monitorizare în producție.

Riscurile de proiect afectează capacitatea proiectului de a-și atinge obiectivele. Exemple:

  • mediul de test sau un serviciu extern (curier, plăți) e indisponibil;
  • livrarea build-urilor întârzie, iar timpul de testare se comprimă;
  • singurul tester cu experiență în domeniu pleacă;
  • cerințele se schimbă des sau sunt aprobate târziu;
  • unelte noi pe care echipa nu le cunoaște.

Răspunsurile posibile la un risc, în terminologia ISTQB: reducere (mitigation), acceptare, transfer (de exemplu, la furnizor sau prin asigurare) sau plan de rezervă (contingency). Exemple: pentru mediul extern instabil, cerem un mock sau o versiune sandbox (reducere) și planificăm testele dependente la final (plan de rezervă); pentru plecarea unui coleg, documentăm și facem sesiuni de transfer de cunoștințe.

În practică, ambele tipuri stau în același registru de riscuri, cu un responsabil și o dată de revizuire. Riscurile de proiect le escaladez devreme managerului; riscurile de produs le folosesc pentru prioritizarea testării.

Ce urmărește intervievatorul: Verifică dacă înțelegi testarea în contextul managementului de proiect. Greșeala tipică este confuzia dintre „mediul nu merge” (proiect) și „aplicația nu merge” (produs).

Greșeala, în practică:Plan de test fără riscuri

66 Senior

Echipa integrează un procesator de plăți extern (de exemplu Stripe sau un procesator local). Cum planifici testarea acestei integrări?

Răspuns scurt: Planifici pe straturi: mediul de test al furnizorului (chei de test, carduri de test), scenariile de plată reușită, refuzată, 3D Secure, rambursare, apoi tratarea erorilor și a timeout-urilor, a notificărilor asincrone (webhooks), a sumelor și reconcilierea cu panoul furnizorului.

Integrările de plată au două particularități: o parte din sistem nu e a ta, iar greșelile costă bani. Planul meu:

Pregătire:

  • citesc documentația furnizorului pentru modul de test; furnizorii mari publică numere de card de test pentru fiecare scenariu (reușită, refuz, fonduri insuficiente, 3D Secure);
  • obțin acces la panoul furnizorului în modul test, ca să verific tranzacțiile din ambele părți;
  • clarific fluxul complet: cine creează plata, cum vine confirmarea (redirect, webhook), ce se întâmplă dacă vin în altă ordine.

Scenarii funcționale:

  • plată reușită, refuzată, anulată de client, 3D Secure reușit și eșuat;
  • rambursare totală și parțială, inclusiv din panoul de administrare;
  • sume cu zecimale, moneda corectă, sume mici și mari, reduceri care aduc totalul la zero.

Robustețe:

  • clientul închide fereastra după plată, înainte de redirect: comanda se marchează plătită când sosește webhook-ul?
  • webhook-ul întârzie, se repetă sau vine de două ori: comanda nu se dublează (idempotență);
  • furnizorul nu răspunde: mesaj clar, fără încasare dublă la reîncercare.

Reconciliere: suma și statusul din aplicație coincid cu cele din panoul furnizorului.

Securitate și conformitate: datele cardului nu trec prin serverele noastre și nu apar în loguri; fluxul respectă cerințele PCI DSS stabilite de echipa tehnică.

Lansare: o tranzacție reală mică, în producție, făcută de echipă și rambursată, plus monitorizarea plăților eșuate în primele zile.

Ce urmărește intervievatorul: Întrebarea de senior verifică dacă știi să planifici testarea unei dependențe externe critice, cu scenariile asincrone. Răspunsul slab se oprește la „plătesc cu un card de test”.

67 Senior

Cum decizi cât de formal documentezi testarea: cazuri scriptate detaliate sau sesiuni exploratorii? Ce se schimbă într-un proiect reglementat, de exemplu o aplicație medicală sau bancară?

Răspuns scurt: Decizi după risc, cerințele de audit, stabilitatea produsului, experiența echipei și cine va folosi documentația. În proiecte reglementate, trasabilitatea, dovezile de execuție, aprobările și păstrarea înregistrărilor devin obligatorii, iar explorarea se documentează și ea.

Nu există un nivel corect universal; documentația costă timp și trebuie să aducă valoare cuiva. Întrebările pe care mi le pun:

  • riscul: o greșeală în calculul dobânzii sau într-o doză de medicament cere teste exacte și repetabile; o pagină de prezentare, nu;
  • cine folosește documentația: testeri noi, auditori, clientul la acceptanță, viitorii colegi de mentenanță;
  • stabilitatea produsului: o interfață care se schimbă săptămânal face ca documentația detaliată să se învechească rapid;
  • experiența echipei în domeniu;
  • cerințe contractuale sau legale.

Într-un produs digital obișnuit, aleg un amestec: cazuri scriptate pentru fluxurile critice și regresie, checklisturi pentru zone cu risc mediu, sesiuni exploratorii cu charter și notițe pentru rest.

Într-un proiect reglementat (de exemplu, software pentru dispozitive medicale, unde se aplică standardul IEC 62304, sau sisteme bancare auditate), se adaugă:

  • trasabilitate completă cerință → risc → test → rezultat → defect;
  • dovezi de execuție păstrate: cine a rulat, când, pe ce versiune, cu ce rezultat, cu capturi;
  • aprobări formale ale planurilor și rapoartelor, cu semnături sau echivalentul lor electronic;
  • controlul modificărilor: orice schimbare a unui caz de test e versionată și justificată;
  • validarea uneltelor folosite, uneori;
  • păstrarea înregistrărilor pe perioade lungi.

Testarea exploratorie nu dispare nici aici, dar se documentează: charter, notițe, defectele găsite, aprobare. Ca senior, stabilesc nivelul împreună cu responsabilul de calitate sau de conformitate, nu pe intuiție.

Ce urmărește intervievatorul: Verifică dacă poți adapta procesul la context, inclusiv la constrângeri legale. Greșeala tipică este „documentez totul mereu” sau „documentația e birocrație”.

Agile, Jira și TestRail

68 Junior

Ce înseamnă criteriile INVEST pentru un user story? Ce întrebări pui, ca tester, la sesiunea de refinement?

Răspuns scurt: INVEST: Independent, Negotiable, Valuable, Estimable, Small, Testable. Ca tester, întrebi mai ales de testabilitate: ce se întâmplă în cazurile limită și de eroare, ce date și ce roluri sunt implicate, cum se vede că funcționează, ce nu intră în story.

INVEST este o listă de calități ale unui story bun, propusă de Bill Wake:

  • Independent: poate fi livrat fără să depindă strict de alt story;
  • Negotiable: detaliile se discută, nu e un contract fix;
  • Valuable: aduce valoare unui utilizator sau clientului;
  • Estimable: echipa îl poate estima;
  • Small: încape într-un sprint;
  • Testable: există criterii clare după care știi că e gata.

Testerul are un rol special la „T”, dar contribuie la toate. Întrebările mele tipice la refinement, pe un story ca „Ca client, vreau să-mi salvez cardul pentru plăți viitoare”:

  • cazuri limită: câte carduri pot salva? Ce se întâmplă când cardul expiră? Dacă îl salvez de două ori?
  • erori: ce vede clientul dacă salvarea eșuează? Dacă banca refuză verificarea?
  • roluri și permisiuni: poate un operator de suport să vadă cardurile salvate? Ce vede exact?
  • date și securitate: unde se stochează cardul? (Răspunsul corect e de obicei: la procesatorul de plăți, nu la noi.) Ce afișăm: ultimele 4 cifre?
  • impact: ce se întâmplă cu fluxul de checkout existent? Cu aplicația mobilă?
  • în afara scopului: ștergerea cardului e în acest story sau în altul?
  • verificare: cum demonstrăm că funcționează? Putem testa pe mediul de test cu carduri de test?

Răspunsurile devin criterii de acceptare. Dacă story-ul e prea mare (de exemplu, include și ștergerea, și cardurile multiple), propun împărțirea lui.

Ce urmărește intervievatorul: Verifică dacă participi activ la refinement, nu doar aștepți story-ul gata implementat. Greșeala tipică este să nu ai nicio întrebare de pus.

69 Junior

Primești story-ul de mai jos. Ce criterii de acceptare lipsesc sau sunt incomplete?

Ca client, vreau să pot aplica un cod de reducere în coș,
ca să plătesc mai puțin.

Criterii de acceptare:
1. Există un câmp „Cod reducere” și un buton „Aplică”.
2. La un cod valid, totalul scade.

Răspuns scurt: Lipsesc: tipurile de reducere (procent, sumă fixă, livrare gratuită), comportamentul la cod invalid, expirat sau deja folosit, pragul minim, cumularea, majusculele și spațiile, eliminarea codului, ce se întâmplă când coșul se modifică după aplicare.

Criteriile actuale descriu doar drumul fericit și o parte din interfață. Ce aș adăuga, ca întrebări sau propuneri:

  • tipul și valoarea reducerii: procent, sumă fixă, livrare gratuită? Reducerea se aplică înainte sau după TVA? Pe livrare sau doar pe produse?
  • cod invalid: ce mesaj apare exact? Câmpul rămâne completat?
  • cod expirat, neînceput încă, epuizat (număr maxim de folosiri atins) și deja folosit de acest client: câte un mesaj distinct sau unul comun?
  • condiții: valoare minimă a coșului, doar anumite categorii sau produse, doar clienți noi, doar clienți logați?
  • cumulare: se pot aplica două coduri? Codul se combină cu produsele deja reduse?
  • formatul: se ignoră diferența între majuscule și minuscule și spațiile de la capete?
  • modificarea coșului după aplicare: dacă scot produse și totalul scade sub prag, codul se elimină automat? Cu ce mesaj?
  • eliminarea codului de către client;
  • persistență: codul rămâne după logout și login, după reîncărcarea paginii, pe alt dispozitiv?
  • afișare: unde se vede reducerea (rând separat, sumă, nume cod) în coș, la checkout, pe factură și în email?
  • protecție: limită de încercări, ca să nu se poată ghici coduri prin încercări repetate.

Nu toate trebuie să intre în acest story; unele pot fi story-uri separate. Important e ca decizia să fie explicită. Criteriul 2 („totalul scade”) îl rescriu verificabil: „La codul TOAMNA10 aplicat pe un coș de 200 lei, totalul devine 180 lei, iar în coș apare rândul «Reducere TOAMNA10: −20 lei».”

Ce urmărește intervievatorul: Exercițiul verifică gândirea critică pe cerințe, înainte de implementare. Greșeala tipică este să accepți criteriile care descriu doar drumul fericit.

70 Junior

Cum folosești Jira ca tester? Scrie o interogare JQL care găsește bug-urile nerezolvate cu prioritate mare din proiectul SHOP, create în ultimele 7 zile.

Răspuns scurt: Folosești Jira pentru story-uri, bug-uri, legături între ele, statusuri și filtre salvate. Interogarea: project = SHOP AND issuetype = Bug AND resolution = Unresolved AND priority in (Highest, High) AND created >= -7d ORDER BY priority DESC, created DESC.

Ca tester, folosesc Jira zilnic pentru:

  • citirea story-urilor și a criteriilor de acceptare, comentarii cu întrebări;
  • raportarea bug-urilor, cu componentă, versiune afectată (Affects Version) și versiune în care se repară (Fix Version);
  • legături între tichete: bug-ul „blochează” story-ul, „e duplicat al”, „e cauzat de”, ca impactul să fie vizibil;
  • mutarea tichetelor prin flux (de exemplu: To Do, In Progress, In Review, In Test, Done) și verificarea defectelor rezolvate;
  • filtre salvate și panouri (dashboards) pentru defectele mele, regresii, bug-urile din release.

Interogarea cerută, în JQL (Jira Query Language):

SQL
project = SHOP
AND issuetype = Bug
AND resolution = Unresolved
AND priority in (Highest, High)
AND created >= -7d
ORDER BY priority DESC, created DESC

Câteva variante utile:

SQL
-- bug-urile rezolvate, care așteaptă retestarea mea
project = SHOP AND issuetype = Bug AND status = Resolved
AND reporter = currentUser()

-- regresiile din versiunea care se lansează
project = SHOP AND labels = regression AND fixVersion = "3.2"

Observații: resolution = Unresolved e mai sigur decât status != Done, pentru că fluxurile diferă între proiecte și pot avea mai multe statusuri finale. Numele priorităților și ale statusurilor depind de configurarea fiecărui Jira; editorul JQL le sugerează automat. Limbajul JQL nu e SQL, dar sintaxa seamănă, de aceea am folosit evidențierea de SQL.

Ce urmărește intervievatorul: Verifică dacă folosești Jira dincolo de „creez tichete”. Greșeala tipică este necunoașterea legăturilor dintre tichete și a filtrelor.

71 Junior

Cum este organizat un proiect în TestRail? Explică diferența dintre cazurile de test, rulările de test (test runs), planurile de test și milestone-uri și cum se leagă TestRail de Jira.

Răspuns scurt: Cazurile stau într-un depozit organizat în secțiuni; o rulare execută o selecție de cazuri pe un build; un plan grupează rulări (de exemplu, pe browsere); milestone-ul le leagă de un release. Cu Jira se leagă prin References și Defects.

Structura TestRail, de sus în jos:

  • Proiect: aplicația sau produsul.
  • Depozitul de cazuri (test suite, sau o singură suită pentru tot proiectul, în modul recomandat pentru majoritatea proiectelor): cazurile de test organizate în secțiuni și subsecțiuni, cu câmpuri precum prioritate, tip, precondiții, pași, rezultate așteptate și References (ID-ul story-ului din Jira, de exemplu SHOP-210).
  • Test run: o execuție concretă a unei selecții de cazuri. Fiecare caz devine un test cu status (Passed, Failed, Blocked, Retest, Untested), comentariu, versiune testată, atașamente. Același caz poate exista în multe rulări fără să fie duplicat.
  • Test plan: grupează mai multe rulări. Exemplu: planul „Regresie 3.2” conține rulări pentru Chrome, Safari și Android, cu aceleași cazuri; TestRail le numește configurații.
  • Milestone: release-ul sau sprintul de care se leagă planurile și rulările; se vede progresul pe release.

Legătura cu Jira, prin integrarea oficială:

  • câmpul References al cazului trimite la story; din story vezi cazurile și rezultatele lor;
  • la un test eșuat, completezi Defects cu ID-ul bug-ului sau creezi bug-ul direct din TestRail, cu pașii precompletați;
  • rapoartele de acoperire arată ce story-uri au teste și ce rezultate.

Alternative cu același model: Zephyr și Xray (care trăiesc în interiorul Jira), qTest. Conceptele (caz, execuție, ciclu, legătură cu cerința) sunt aceleași, doar denumirile diferă.

Ce urmărește intervievatorul: Verifică experiența practică cu o unealtă de management al testelor. Greșeala tipică este să confunzi cazul de test cu rezultatul lui dintr-o rulare.

72 Mid

Explică cadranele testării Agile. În ce cadran încadrezi testele unitare, testele de acceptanță ale story-ului, testarea exploratorie și testarea de performanță?

Răspuns scurt: Cadranele (Brian Marick, popularizate de Lisa Crispin și Janet Gregory) împart testele după două axe: orientate spre tehnologie sau spre business, și care sprijină echipa sau critică produsul. Unitare: Q1; acceptanța story-ului: Q2; exploratorie: Q3; performanță: Q4.

Modelul are două axe:

  • orientare: teste orientate spre tehnologie (vorbesc limbajul developerilor) sau spre business (vorbesc limbajul clientului);
  • scop: teste care sprijină echipa în timpul dezvoltării (ghidează construcția) sau care critică produsul (evaluează produsul construit, caută ce lipsește).

Cele patru cadrane:

  • Q1, tehnologie + sprijin: teste unitare și de componentă, de obicei automatizate, scrise de developeri;
  • Q2, business + sprijin: teste funcționale, teste de acceptanță ale story-ului, exemple, prototipuri, simulări; manuale sau automatizate, scrise împreună cu Product Owner-ul;
  • Q3, business + critică: testare exploratorie, de utilizabilitate, UAT, testare alfa și beta, demonstrații cu utilizatori; în principal manuale;
  • Q4, tehnologie + critică: performanță, încărcare, securitate, fiabilitate, alte caracteristici nefuncționale; în principal cu unelte.

Deci: unitarele în Q1, acceptanța story-ului în Q2, explorarea în Q3, performanța în Q4.

La ce folosește modelul: nu e o ordine de execuție, ci o hartă care arată dacă echipa uită ceva. Multe echipe au Q1 și Q2 bine acoperite și aproape nimic în Q3 și Q4: nimeni nu explorează și nimeni nu testează performanța până la primul incident. Ca tester, folosesc cadranele la planificarea unui release ca să întreb: cine se ocupă de fiecare cadran și când?

Ce urmărește intervievatorul: Verifică familiaritatea cu un model clasic din testarea Agile și aplicarea lui. Greșeala tipică este să crezi că cadranele reprezintă etape succesive.

73 Mid

Ce este un feature flag și cum testezi o funcționalitate ascunsă sub un flag? Ce riscuri suplimentare introduce?

Răspuns scurt: Feature flag-ul e un comutator de configurare care pornește sau oprește o funcționalitate fără deploy nou. Testezi ambele stări (pornit și oprit), trecerea dintre ele cu date existente, țintirea pe utilizatori sau procente și curățarea flag-ului după lansare.

Flag-urile permit livrarea codului în producție înainte ca funcționalitatea să fie vizibilă: echipa o pornește întâi pentru angajați, apoi pentru 5% din utilizatori, apoi pentru toți. Pentru tester, asta schimbă modul de lucru.

Ce testez:

  • flag oprit: aplicația se comportă exact ca înainte; este regresia cea mai importantă, pentru că așa ajunge codul la toți clienții la început;
  • flag pornit: funcționalitatea nouă, ca la orice story;
  • comutarea cu date existente: un client are coșul creat cu flag-ul oprit, apoi flag-ul se pornește (și invers). Ce se întâmplă cu datele create de funcționalitatea nouă dacă flag-ul se oprește din nou?
  • țintirea: flag-ul pornit doar pentru un segment (angajați, o țară, un procent). Verific că exact acei utilizatori văd funcționalitatea, inclusiv după logout și login sau pe alt dispozitiv;
  • consistența între componente: backendul și frontendul, aplicația web și cea mobilă citesc același flag? Nu vreau un buton vizibil care apelează un API încă oprit;
  • combinații de flag-uri, dacă mai multe funcționalități se suprapun în aceeași zonă.

Riscurile suplimentare:

  • combinațiile de flag-uri cresc numărul de configurații de testat;
  • flag-urile uitate în cod după lansare devin datorie tehnică și pot fi pornite greșit;
  • datele de testare din producție (cu flag pornit doar pentru echipă) trebuie separate de cele reale.

Cer ca în tichet să fie scris numele flag-ului și cum îl pot comuta pe mediul de test, plus un tichet de curățare după lansarea completă.

Ce urmărește intervievatorul: Verifică dacă înțelegi practicile moderne de livrare și impactul lor asupra testării. Greșeala tipică este să testezi doar cu flag-ul pornit.

74 Mid

Cum aduci problemele de calitate în discuție la retrospectiva sprintului, fără ca discuția să devină o vânătoare de vinovați?

Răspuns scurt: Vii cu fapte și tipare, nu cu persoane: ce s-a întâmplat, ce impact a avut, ce credem că a cauzat problema. Propui o acțiune mică și măsurabilă, cu un responsabil, și verifici la retrospectiva următoare dacă a funcționat.

Retrospectiva e locul în care testerul poate schimba procesul, nu doar raporta bug-uri. Cum o pregătesc:

  • adun fapte din sprint: câte story-uri au ajuns la testare în ultimele două zile, câte defecte au fost redeschise, ce defecte au scăpat în producție, cât timp au stat build-urile blocate;
  • caut tipare, nu incidente izolate: „în ultimele trei sprinturi, majoritatea story-urilor au ajuns la testare în ultima zi”, spus doar dacă datele echipei o arată;
  • formulez problema ca problemă a echipei: „story-urile ajung târziu la testare și testăm în grabă” în loc de „developerii livrează târziu”;
  • propun cauze posibile și ascult ce spun ceilalți; poate story-urile sunt prea mari sau review-ul de cod durează;
  • propun o singură acțiune concretă și măsurabilă: „împărțim story-urile mai mari de 5 puncte la refinement” sau „primul story ajunge la testare până miercuri”, cu un responsabil;
  • revin la retrospectiva următoare cu efectul.

Ce evit: nume de persoane, generalizări („mereu”, „niciodată”), liste de 10 probleme deodată, plângeri fără propunere.

Merită adus și ce a mers bine, de exemplu un defect important prins la refinement datorită unei întrebări a unui developer. Calitatea devine o temă a echipei când toată lumea vede și reușitele.

Dacă e o problemă sensibilă care ține de o persoană, o discut separat cu acea persoană sau cu Scrum Master-ul, nu în fața echipei.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică maturitatea în colaborare și capacitatea de a îmbunătăți procesul. Greșeala tipică este o listă de reproșuri.

75 Senior

În ultimele sprinturi, majoritatea story-urilor ajung la testare în ultima zi a sprintului („mini-waterfall”). Cum rezolvi problema împreună cu echipa?

Răspuns scurt: Atacă fluxul, nu doar testarea: story-uri mai mici, limită de lucru în paralel, testarea începută înainte de terminarea codului (criterii de acceptare și teste pregătite, build-uri intermediare), developeri care testează și ei, iar Definition of Done care include testarea în sprint.

Simptomul e la testare, dar cauza e aproape mereu în fluxul echipei: prea multe story-uri începute deodată, story-uri mari, livrare spre testare doar când totul e gata. Ce aș propune, gradual:

  • story-uri mai mici: împărțite pe felii verticale (de exemplu, „aplic cod procentual” separat de „aplic cod sumă fixă”), ca primele să fie gata în primele zile;
  • limitarea lucrului în paralel: echipa termină un story, inclusiv testarea, înainte să înceapă altele; pe panou, limită de story-uri în coloana „In Progress”, ca în Kanban;
  • testare în paralel cu dezvoltarea: criteriile de acceptare și cazurile de test gata la începutul sprintului; testez pe branch-ul de feature sau pe un mediu efemer, înainte de merge; developerul îmi arată funcționalitatea devreme;
  • pair testing developer-tester pe funcționalitățile riscante;
  • developerii testează și ei: rulează testele de acceptanță pregătite de mine înainte de a muta story-ul în testare; dacă testarea e blocajul, echipa ajută la testare, nu începe alt story;
  • automatizarea regresiei, ca ultima zi să nu fie ocupată și cu regresie manuală;
  • Definition of Done care include testarea și reparațiile, astfel încât un story netestat să nu fie „gata”.

Cum conduc schimbarea: aduc datele la retrospectivă (când au ajuns story-urile la testare în ultimele sprinturi), propun un experiment de un sprint sau două, cu o măsură clară (de exemplu, primul story testat până în ziua 3) și decidem apoi împreună. Ca senior, nu cer ore suplimentare la testare, ci schimbarea fluxului.

Ce urmărește intervievatorul: Verifică dacă poți influența procesul echipei, nu doar te adaptezi la el. Răspunsul slab este „lucrez mai mult în ultimele zile” sau „cer mai mulți testeri”.

76 Senior

Ești singurul tester într-o echipă cu șapte developeri. Nu poți testa totul în fiecare sprint. Cum organizezi calitatea în echipă?

Răspuns scurt: Treci de la „testez eu tot” la „ajut echipa să testeze bine”: implici devreme criteriile de acceptare, developerii testează pe baza checklisturilor tale, faci pair testing pe zonele riscante, automatizezi regresia stabilă, te concentrezi pe risc și explorare și faci vizibil ce rămâne netestat.

Raportul de un tester la mulți developeri e frecvent. Dacă încerci să fii singurul filtru, devii blocajul echipei și calitatea scade oricum. Ce aș face:

  • shift-left: particip la refinement și transform întrebările mele în criterii de acceptare clare; un defect prevenit acolo nu mai trebuie găsit;
  • developerii își testează munca: le dau checklisturi pe tipuri de funcționalități (formulare, liste, permisiuni) și cazuri de acceptanță pe care le rulează înainte să mute story-ul în testare; Definition of Done include asta;
  • pair testing: 30–60 de minute cu developerul pe story-urile riscante, pe mediul lui, înainte de merge; el învață cum gândesc eu, eu înțeleg cum e construit;
  • concentrarea mea pe risc: story-urile cu bani, date personale sau integrări primesc testarea mea completă; cele cu risc mic primesc doar o verificare scurtă sau sunt testate de un alt developer;
  • automatizarea regresiei stabile, împreună cu developerii (testele unitare și de API le scriu ei, eu propun scenariile);
  • sesiuni de explorare cu toată echipa înainte de release (bug bash), cu charter-e împărțite;
  • vizibilitate: la planificare spun ce nu voi putea testa în profunzime, ca Product Owner-ul să accepte riscul conștient sau să schimbe prioritățile.

Rolul meu devine cel de coach de calitate și de specialist în riscuri, nu doar de executant. Măsor efectul pe date: defecte scăpate în producție, story-uri redeschise, timpul în coloana „In Test”, și le aduc la retrospectivă.

Ce urmărește intervievatorul: Întrebarea de senior verifică dacă poți scala calitatea prin echipă, nu prin efort personal. Răspunsul slab este „lucrez peste program” sau „cer încă trei testeri”.

Testare web, API și mobil

77 Junior

Cum testezi o pagină responsive folosind DevTools? Ce verifici și ce limite are emularea din browser față de un telefon real?

Răspuns scurt: Folosești modul dispozitiv din DevTools pentru lățimi diferite (inclusiv cele dintre breakpoint-uri), orientare, zoom și throttling. Verifici aranjarea, textele tăiate, meniul, imaginile, butoanele ușor de apăsat. Emularea nu reproduce exact Safari iOS, tastatura, performanța și gesturile reale.

În Chrome, deschizi DevTools (F12) și activezi Device Toolbar (Ctrl+Shift+M, Cmd+Shift+M pe Mac). Poți alege dispozitive predefinite sau poți trage de margine pentru orice lățime.

Ce verific:

  • breakpoint-urile: lățimile la care se schimbă aranjarea (de exemplu 768 px, 1024 px) și valorile de lângă ele (767, 769), unde apar des defecte;
  • lățimi foarte mici (320 px) și foarte mari (2560 px);
  • conținutul: texte tăiate sau suprapuse, cuvinte lungi care ies din container, tabele care forțează derularea orizontală a întregii pagini;
  • navigarea: meniul se transformă corect în meniu hamburger și se poate închide;
  • imaginile: proporții, dimensiuni, versiunea potrivită încărcată pentru ecran mic (se vede în Network);
  • zonele de atingere: butoane suficient de mari și distanțate (WCAG 2.2 cere minimum 24×24 px pentru țintele de atingere, cu unele excepții);
  • orientarea portret și peisaj, zoom 200% pe desktop;
  • formularele: tastatura potrivită pe mobil (type="email", type="tel").

Limitele emulării:

  • Chrome emulează dimensiunea și user agent-ul, dar folosește motorul lui de randare; Safari pe iOS e alt motor și are comportamente proprii (bara de adresă care își schimbă înălțimea, zoom automat pe câmpurile cu font mic, date picker);
  • tastatura virtuală care acoperă jumătate de ecran nu apare;
  • performanța reală a unui telefon mai slab nu se vede;
  • gesturile, senzorii, notificările și întreruperile lipsesc.

De aceea emularea e bună pentru prima trecere, rapidă, dar finalul se verifică pe câteva dispozitive reale sau într-un serviciu cloud cu dispozitive reale.

Ce urmărește intervievatorul: Verifică dacă știi să folosești uneltele browserului și dacă le cunoști limitele. Greșeala tipică este să consideri testarea în device mode echivalentă cu testarea pe iPhone.

Greșeala, în practică:Testat doar pe desktopTestat doar în emulator

78 Junior

Apeși „Salvează” într-un formular și nu se întâmplă nimic. Cum folosești DevTools ca să afli dacă problema e în frontend sau în backend, înainte să raportezi?

Răspuns scurt: Te uiți în Console după erori JavaScript și în Network după request: dacă nu pleacă niciun request, problema e probabil în frontend; dacă pleacă și primește 4xx sau 5xx, te uiți la răspuns; dacă primește 200, dar interfața nu se actualizează, e din nou frontend.

Un raport de tipul „butonul nu merge” e corect, dar câteva minute de investigație îl fac mult mai util. Pașii:

  • deschid DevTools înainte de a apăsa butonul, ca să nu pierd informații; în Network bifez Preserve log, ca request-urile să rămână și după o redirecționare;
  • apăs „Salvează” și mă uit în Console: o eroare roșie de tipul TypeError: Cannot read properties of undefined arată o problemă în codul JavaScript din pagină;
  • mă uit în Network (filtrul Fetch/XHR):
  • niciun request: butonul nu declanșează trimiterea; cauza e în frontend (eroare JavaScript, validare care blochează fără să afișeze mesajul, buton dezactivat de un element suprapus);
  • request cu 4xx: serverul refuză datele; citesc răspunsul (de exemplu, 400 cu "phone": "invalid format", deci interfața nu afișează eroarea primită; 401 sau 403, deci problemă de sesiune sau permisiuni);
  • request cu 5xx: eroare pe server; developerul are nevoie de ora exactă pentru loguri;
  • request cu 200 sau 201: serverul a salvat, dar interfața nu reflectă rezultatul; verific dacă datele apar după reîncărcare;
  • request în așteptare (pending) mult timp: problemă de performanță sau de timeout.

În raport pun ce am găsit ca fapte: „Request-ul PUT /api/profile întoarce 400 cu mesajul X; interfața nu afișează nicio eroare”. Pot adăuga, ca ipoteză separată, unde cred că e problema, dar nu atribui direct defectul echipei de frontend sau de backend; decizia o ia echipa.

Ce urmărește intervievatorul: Verifică dacă știi să faci o investigație de bază care scurtează mult reparația. Greșeala tipică este raportul fără nicio informație tehnică sau un diagnostic prezentat ca sigur.

79 Junior

Ce testezi la sesiune, cookie-uri și logout într-o aplicație web? Ce poți verifica în tab-ul Application din DevTools?

Răspuns scurt: Testezi că logout-ul invalidează sesiunea (butonul Înapoi și linkurile salvate nu mai dau acces), că sesiunea expiră după inactivitate, comportamentul în mai multe taburi și dispozitive și opțiunea „ține-mă minte”. În Application vezi cookie-urile, atributele lor, localStorage și sessionStorage.

Sesiunea e locul unde se întâlnesc funcționalitatea și securitatea. Ce verific:

  • logout: după ieșire, butonul Înapoi nu afișează pagini cu date personale (sau, dacă afișează din cache, orice acțiune cere din nou autentificare); un URL copiat dinainte (/contul-meu/comenzi) trimite la login;
  • expirarea: după perioada de inactivitate stabilită, următoarea acțiune cere autentificare, cu un mesaj clar; datele dintr-un formular lung completat nu se pierd fără avertisment, dacă cerința spune asta;
  • mai multe taburi: logout într-un tab, apoi acțiune în celălalt;
  • mai multe dispozitive: schimbarea parolei închide celelalte sesiuni, dacă e cerință;
  • „ține-mă minte”: cât timp rămâne utilizatorul logat după închiderea browserului, cu și fără bifă;
  • ce e salvat local: coșul unui vizitator, preferințele de limbă, consimțământul pentru cookie-uri.

În DevTools, tab-ul Application arată:

  • Cookies: numele, valoarea, domeniul, expirarea și atributele. Pentru cookie-ul de sesiune, mă aștept la HttpOnly (nu poate fi citit din JavaScript), Secure (doar pe HTTPS) și un SameSite potrivit;
  • Local Storage și Session Storage: date salvate de pagină; verific să nu conțină parole, date de card sau tokenuri cu durată lungă, dacă politica echipei interzice asta;
  • butonul Clear site data, util ca să simulezi un utilizator nou.

Testele utile: șterg doar cookie-ul de sesiune și reîncarc (trebuie să ajung la login); modific manual o valoare, de exemplu un rol salvat local, și verific că serverul nu se bazează pe ea.

Ce urmărește intervievatorul: Verifică dacă știi să testezi starea dintre pagini, nu doar paginile. Greșeala tipică este să verifici doar că butonul de logout duce la pagina de login.

80 Junior

Dincolo de validarea câmpurilor, ce verifici la un formular web de înregistrare?

Răspuns scurt: Ordinea de navigare cu Tab și trimiterea cu Enter, etichetele și mesajele de eroare, păstrarea datelor după eroare, dublu click la trimitere, autocompletarea browserului, lipirea textului, butonul Înapoi și reîncărcarea, emailul de confirmare, comportamentul pe mobil și cu cititorul de ecran.

Validarea fiecărui câmp e doar o parte. Lista mea pentru un formular de înregistrare:

  • navigarea cu tastatura: Tab trece prin câmpuri în ordinea vizuală, Enter trimite formularul, focusul e vizibil;
  • etichete: fiecare câmp are etichetă vizibilă (nu doar text de exemplu care dispare la tastare), iar câmpurile obligatorii sunt marcate;
  • mesajele de eroare: apar lângă câmpul greșit, spun cum se corectează, focusul ajunge la prima eroare, iar datele completate corect nu se șterg; parola, de obicei, se golește, iar asta trebuie să fie o decizie conștientă;
  • trimiterea: butonul se dezactivează după primul click, apare un indicator, nu se creează două conturi la dublu click sau la Enter apăsat de mai multe ori;
  • autocompletarea browserului și a managerelor de parole funcționează (autocomplete="email", new-password);
  • lipirea textului în câmpuri, inclusiv în cel de confirmare a parolei (unele formulare o blochează, ceea ce încurcă utilizatorii de manager de parole);
  • arătarea parolei (iconul cu ochi), dacă există;
  • Înapoi și reîncărcare după trimitere: nu se retrimite formularul fără avertisment;
  • după înregistrare: emailul de confirmare ajunge, linkul funcționează o singură dată și expiră, contul neconfirmat are restricțiile stabilite;
  • acordurile: bifele pentru termeni și marketing nu sunt prebifate, iar consimțământul se salvează;
  • mobil: tastatura potrivită pentru fiecare câmp, butonul nu e ascuns de tastatură;
  • cititor de ecran: câmpurile și erorile sunt anunțate.

Ce urmărește intervievatorul: Verifică dacă te gândești la experiența completă, nu doar la reguli de validare. Greșeala tipică este o listă de 30 de valori invalide pentru email și nimic altceva.

81 Junior

Cum testezi manual în Postman un endpoint POST /api/orders care creează o comandă? Ce setezi în request și ce verifici în răspuns?

Răspuns scurt: Setezi metoda, URL-ul, headerul Content-Type: application/json, autentificarea (de exemplu un token Bearer) și corpul JSON. Verifici codul de stare (de obicei 201), corpul răspunsului, headerele relevante, apoi confirmi cu un GET sau în interfață că comanda chiar există, cu datele corecte.

Pașii în Postman:

  • metoda POST și URL-ul, ideal cu o variabilă de mediu: {{baseUrl}}/api/orders;
  • tab-ul Authorization: tipul cerut de API, de exemplu Bearer Token cu tokenul obținut la login, salvat ca variabilă;
  • tab-ul Body: raw și JSON; Postman adaugă automat headerul Content-Type: application/json;
  • corpul, după documentația API-ului:
JSON
{
  "items": [
    {"productId": "CA-01", "quantity": 2}
  ],
  "deliveryMethod": "courier",
  "couponCode": "TOAMNA10"
}

Ce verific în răspuns:

  • statusul: de obicei 201 Created la creare (sau 200, dacă așa e documentat);
  • corpul: ID-ul comenzii, statusul inițial, totalul calculat corect (prețul × cantitatea, minus reducerea, plus livrarea), moneda;
  • headerele: uneori Location cu adresa resursei noi;
  • timpul de răspuns, afișat de Postman;
  • efectul real: GET /api/orders/{id} întoarce aceeași comandă; comanda apare în interfață și în administrare; stocul a scăzut.

Apoi variez câte un lucru: fără token (aștept 401), cu tokenul altui utilizator pe o resursă care nu e a lui (403 sau 404), cantitate 0 sau negativă, produs inexistent, JSON invalid, câmp obligatoriu lipsă (de obicei 400 sau 422, cu mesaj clar). Fiecare request bun îl salvez în colecție, ca să-l pot relua la regresie.

Atenție: prețul nu trebuie acceptat din request; dacă trimit "price": 1 și comanda îl folosește, e un defect grav.

Ce urmărește intervievatorul: Verifică dacă știi să faci primul test de API manual, cu verificarea efectelor, nu doar a răspunsului. Greșeala tipică este să te oprești la „a venit 200”.

Greșeala, în practică:Verificat doar status 200JSON invalid netestat (400)

82 Junior

Uită-te la răspunsul API de mai jos pentru o comandă plătită. Ce probleme observi?

JSON
{
  "id": 1042,
  "status": "paid",
  "total": "149.90",
  "currency": "RON",
  "items": [
    {"sku": "CA-01", "qty": 2, "price": 59.95},
    {"sku": "CA-02", "qty": 1, "price": 29.00}
  ],
  "customerEmail": null,
  "createdAt": "2026-10-31 14:03"
}

Răspuns scurt: Suma produselor e 148,90, nu 149,90 (diferența trebuie explicată, de exemplu prin livrare, care lipsește din răspuns); total e text, iar prețurile sunt numere; o comandă plătită fără email al clientului; data nu are fus orar și nu e în format ISO 8601 complet.

Analizez pe rând consistența datelor, tipurile și formatul.

  • Calculul: 2 × 59,95 = 119,90, plus 29,00, adică 148,90. Totalul afișat e 149,90. Poate diferența de 1 leu e o taxă sau o livrare, dar răspunsul nu conține niciun câmp care să o explice. Fie e un defect de calcul, fie lipsesc câmpurile de livrare, taxe și reduceri, fără de care clientul nu poate verifica suma.
  • Tipuri inconsistente: total e șir de caractere ("149.90"), iar price e număr. Clientul API-ului (aplicația web sau mobilă) poate face calcule greșite sau comparații de text. Contează și ce spune documentația (contractul API): dacă specifică număr, e un defect.
  • Date lipsă: customerEmail e null la o comandă plătită. Cum se trimite confirmarea? E o comandă de vizitator fără email salvat sau o problemă de mapare?
  • Data: "2026-10-31 14:03" nu are fus orar, nici secunde, și nu respectă formatul ISO 8601 complet (2026-10-31T14:03:00+02:00 sau în UTC, cu Z). Aplicațiile din alte fusuri orare o vor interpreta diferit.
  • Denumiri: qty față de quantity, dacă restul API-ului folosește alt stil; e o observație minoră.
  • Status: valoarea paid e permisă de documentație? Statusurile ar trebui să fie dintr-o listă fixă.

În raport separ defectul probabil (totalul) de problemele de contract (tipuri, format de dată) și de întrebări (emailul). Verific și în interfață ce total vede clientul.

Ce urmărește intervievatorul: Exercițiul verifică atenția la detalii și capacitatea de a citi JSON ca tester. Mulți candidați verifică doar că răspunsul „arată bine” și nu refac calculul.

Greșeala, în practică:Verificat doar status 200Tipurile din JSON neverificate

83 Junior

Ce este specific testării aplicațiilor mobile față de testarea web? Când folosești un emulator și când un dispozitiv real?

Răspuns scurt: Pe mobil apar întreruperi (apeluri, notificări), rotirea ecranului, permisiuni, rețea variabilă, baterie, fundal și revenire, instalare și actualizare, gesturi și fragmentarea dispozitivelor. Emulatorul e bun pentru verificări funcționale rapide; dispozitivul real e necesar pentru performanță, cameră, notificări, senzori și aspect real.

Ce trebuie testat în plus pe mobil:

  • ciclul de viață: aplicația trimisă în fundal și readusă, închisă de sistem din lipsă de memorie, pornită dintr-o notificare sau dintr-un link;
  • întreruperi: apel primit, alarmă, notificare, conectarea căștilor, ecranul blocat în timpul unei operații;
  • rețea: trecere Wi-Fi → date mobile, mod avion, semnal slab; aplicația afișează un mesaj clar și își revine;
  • permisiuni: refuz, acordare ulterioară din setări, „doar de data aceasta” (pe Android și iOS există variante de permisiuni temporare);
  • rotirea ecranului și păstrarea datelor completate;
  • instalare și actualizare: update de la versiunea anterioară fără pierderea datelor sau a sesiunii, dezinstalare și reinstalare;
  • setările sistemului: mod întunecat, font mărit, limbă, economisirea bateriei;
  • gesturi: glisare înapoi pe iOS, butonul Înapoi pe Android, tragere pentru reîmprospătare;
  • fragmentarea: multe modele, dimensiuni, versiuni de sistem și producători cu modificări proprii, mai ales pe Android;
  • magazinele de aplicații: regulile Apple și Google pot respinge o versiune.

Emulatorul (Android Studio) sau simulatorul (Xcode, pentru iOS) e gratuit, rapid de configurat pe multe versiuni și bun pentru testarea funcțională și pentru capturi. Dispozitivul real e necesar pentru performanță și consum de baterie, cameră, NFC, biometrie, notificări push reale, comportamentul tastaturii, rețea reală și pentru felul în care arată ecranul. Practica obișnuită: emulatoare în timpul dezvoltării, câteva dispozitive reale reprezentative pentru verificarea finală și un serviciu cloud cu dispozitive reale pentru acoperire largă.

Ce urmărește intervievatorul: Verifică dacă știi ce aduce mobilul în plus și dacă poți justifica alegerea uneltei. Greșeala tipică este să tratezi aplicația mobilă ca pe un site mai mic.

Greșeala, în practică:Întreruperile netestate pe mobilTestat doar în emulator

84 Mid

Formularul din interfață nu permite o cantitate mai mare de 10 bucăți. Cum verifici dacă regula există și pe server, nu doar în frontend?

Răspuns scurt: Trimiți cererea ocolind interfața: în Postman, cu același request pe care îl face pagina, dar cu cantitatea 11, sau modifici atributele câmpului din DevTools. Dacă serverul acceptă, regula e doar în frontend, iar asta e un defect, de obicei grav.

Validarea în frontend e pentru confortul utilizatorului; cea de pe server e cea care protejează datele. Orice regulă de business (limite, prețuri, permisiuni) trebuie verificată și pe server, pentru că oricine poate trimite request-uri direct.

Metoda 1, Postman:

  • în DevTools, tab-ul Network, fac adăugarea în coș cu o cantitate validă și găsesc request-ul (de exemplu, POST /api/cart/items);
  • click dreapta, Copy as cURL, apoi în Postman Import → Raw text; request-ul vine cu tot cu headere și cookie-ul de sesiune;
  • schimb "quantity": 2 în 11, apoi 0, −1, 2.5, "abc", 1000000 și trimit pe rând.

Metoda 2, DevTools pe pagină: în tab-ul Elements, pe câmpul de cantitate, șterg sau modific atributul max="10" (sau maxlength, disabled), apoi trimit formularul. E rapid, dar nu ocolește validarea scrisă în JavaScript.

Rezultatul așteptat: serverul refuză valoarea cu un cod de eroare (de obicei 400 sau 422) și un mesaj, iar coșul nu se modifică. Verific și indirect: reîncarc pagina coșului și mă uit ce cantitate apare.

Aceeași tehnică se aplică pentru prețuri trimise din frontend, ID-uri ale altor utilizatori, câmpuri ascunse (role, discount), acțiuni pe care un buton dezactivat le ascunde.

Fac aceste teste doar pe mediile de test. Defectul îl raportez cu request-ul exact folosit, fără token valid în clar în tichet.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre validarea din interfață și regulile de pe server. Greșeala tipică este să consideri regula testată pentru că butonul „+” nu trece de 10.

85 Mid

Cum testezi o aplicație mobilă de cumpărături atunci când conexiunea se pierde exact în timpul plății?

Răspuns scurt: Reproduci pierderea conexiunii în momente diferite ale plății (înainte de trimitere, după trimitere, în timpul autentificării la bancă), apoi verifici că nu apare plată dublă, că starea comenzii devine corectă și că utilizatorul primește un mesaj clar.

Problema are o parte de interfață și una de integritate a datelor. Cele mai grave defecte sunt încasarea fără comandă sau încasarea dublă.

Cum provoc pierderea conexiunii:

  • mod avion activat la momentul ales;
  • pe emulatorul Android, setările de rețea; pe iOS, utilitarul Network Link Conditioner (din uneltele pentru developeri Apple), cu profiluri de rețea slabă;
  • un proxy precum Charles sau mitmproxy, care poate întârzia sau bloca un anumit request (unde echipa permite).

Momentele pe care le testez:

  • înainte de apăsarea „Plătește”: aplicația detectează lipsa rețelei și nu trimite nimic;
  • imediat după trimiterea cererii de plată, înainte de răspuns: e cel mai riscant moment;
  • în timpul autentificării 3D Secure, în aplicația sau pagina băncii;
  • după confirmarea băncii, înainte ca aplicația să primească rezultatul.

Ce verific după revenirea conexiunii:

  • starea comenzii în aplicație, pe web și în administrare: plătită, neplătită sau în așteptare, dar niciodată neclară pentru client;
  • tranzacțiile în panoul de test al procesatorului de plăți: o singură încasare;
  • reîncercarea: dacă utilizatorul apasă din nou „Plătește”, nu apare a doua încasare (serverul trebuie să recunoască aceeași cerere, prin chei de idempotență sau o verificare echivalentă);
  • mesajul către utilizator: ce s-a întâmplat și ce poate face;
  • coșul e păstrat dacă plata nu a reușit;
  • notificarea și emailul sosesc o singură dată.

Repet testele pe Android și iOS, pentru că fiecare gestionează diferit rețeaua și aplicațiile din fundal.

Ce urmărește intervievatorul: Verifică dacă te gândești la integritatea tranzacțiilor, nu doar la mesajul de eroare. Greșeala tipică este un singur test cu modul avion pornit înainte de plată.

Greșeala, în practică:Întreruperile netestate pe mobil

86 Mid

Ce teste faci pentru o funcționalitate de încărcare a pozei de profil, cu limita de 5 MB și formatele JPG și PNG?

Răspuns scurt: Dimensiuni la limită (puțin sub, exact și puțin peste 5 MB), formate permise și interzise, extensii false, fișiere corupte, nume cu diacritice și spații, imagini foarte mari ca rezoluție, încărcare anulată, conexiune lentă, înlocuire și ștergere, plus verificarea pe server, nu doar în interfață.

Împart testele în câteva grupe.

Dimensiunea, cu fișiere pregătite dinainte:

  • 4,9 MB, aproape de 5 MB și puțin peste; atenție: „5 MB” poate însemna 5.000.000 sau 5.242.880 de octeți, iar regula trebuie clarificată;
  • un fișier gol (0 octeți);
  • un fișier mult peste limită, de exemplu 50 MB: eroarea apare repede sau abia după încărcarea completă?

Formatul:

  • JPG, JPEG, PNG, cu extensii scrise cu majuscule (.JPG);
  • formate nepermise: GIF, WebP, HEIC (formatul implicit de pe iPhone, deci un caz foarte frecvent), PDF;
  • extensie falsă: un fișier text redenumit poza.jpg; serverul ar trebui să verifice conținutul, nu doar extensia;
  • un fișier SVG redenumit, care poate conține script; e relevant pentru securitate;
  • imagine coruptă (descărcare întreruptă).

Conținutul imaginii: rezoluție foarte mare, imagine foarte îngustă sau foarte lată, orientare din metadatele EXIF (poza făcută cu telefonul în portret apare rotită?), transparența PNG.

Fișierul și fluxul: nume cu diacritice, spații, nume foarte lung; încărcare prin drag and drop și prin selector; anularea încărcării; conexiune lentă (bară de progres, buton blocat); înlocuirea pozei și ștergerea ei; pe mobil, alegerea din galerie și direct din cameră, cu permisiunea refuzată.

Pe server: aceleași limite verificate prin Postman; poza veche e ștearsă sau înlocuită; metadatele cu locația GPS sunt eliminate, dacă politica de confidențialitate cere; imaginea afișată în alte locuri (comentarii, antet) e actualizată.

Ce urmărește intervievatorul: Verifică dacă aplici tehnicile pe fișiere și dacă te gândești la securitate. Greșeala tipică este să uiți de HEIC, de extensiile false și de definiția exactă a limitei.

87 Mid

Cum verifici manual accesibilitatea unui flux de checkout folosind doar tastatura și un cititor de ecran? Ce probleme găsești cel mai des?

Răspuns scurt: Parcurgi tot fluxul fără mouse: Tab, Shift+Tab, Enter, Space, săgeți și Escape. Verifici că focusul e vizibil, ordinea e logică, nu rămâi blocat. Cu NVDA sau VoiceOver asculți dacă etichetele, erorile și schimbările sunt anunțate. Cele mai frecvente: focus invizibil, butoane fără nume, erori neanunțate.

Unelte automate precum Lighthouse sau axe găsesc doar o parte din problemele de accesibilitate. Testarea manuală cu tastatura și cu un cititor de ecran le prinde pe cele mai importante pentru utilizatori.

Doar tastatura, pe tot checkout-ul:

  • Tab ajunge la fiecare element interactiv, în ordinea vizuală;
  • focusul e vizibil în orice moment (un contur clar);
  • nu există capcane de tastatură: dintr-o fereastră modală ieși cu Escape, iar focusul revine unde era;
  • controalele personalizate (liste derulante, selector de dată, butoane radio pentru livrare) funcționează cu Enter, Space și săgeți;
  • linkul „Sari la conținut”, dacă există.

Cititor de ecran: NVDA (gratuit, pe Windows), VoiceOver (pe macOS și iOS), TalkBack (pe Android):

  • câmpurile își anunță eticheta și dacă sunt obligatorii;
  • butoanele cu iconițe au nume („Șterge produsul”, nu „buton”);
  • erorile de validare sunt anunțate când apar, nu doar colorate cu roșu;
  • schimbările dinamice (totalul actualizat, „Produs adăugat în coș”) sunt anunțate;
  • imaginile produselor au text alternativ util, iar cele decorative sunt ignorate.

Mai verific: contrastul textului (WCAG cere minimum 4,5:1 pentru textul normal), zoom 200% fără pierdere de conținut, informația care nu e transmisă doar prin culoare.

Problemele cele mai frecvente: focus ascuns prin CSS, butoane făcute din div, erori neanunțate, ferestre modale din care nu poți ieși. Le raportez cu trimitere la criteriul WCAG încălcat, de exemplu 2.4.7 Focus Visible.

Ce urmărește intervievatorul: Verifică dacă știi să testezi accesibilitatea practic, nu doar să numești standardul. Greșeala tipică este să te bazezi doar pe un scor Lighthouse.

Greșeala, în practică:Accesibilitatea ignoratăNavigarea cu tastatura netestată

Exerciții practice și situații

Exersează capitolul cu exerciții reale: Curs testare manuală pentru începători →
88 Junior

Cum ai testa blocarea contului după 5 încercări greșite de login și opțiunea „Ține-mă minte”?

Răspuns scurt: Pentru blocare: valorile limită (4, 5, 6 încercări), resetarea contorului după login reușit, durata blocării, mesajele, deblocarea și comportamentul pentru un email inexistent. Pentru „Ține-mă minte”: durata sesiunii cu și fără bifă, după închiderea browserului, după logout și după schimbarea parolei.

Blocarea contului, presupunând regula „după 5 încercări greșite consecutive, contul se blochează 15 minute”:

  • 4 încercări greșite, apoi parola corectă: login reușit; contorul se resetează?
  • exact 5 greșite: contul se blochează; a 6-a încercare, chiar cu parola corectă, e refuzată cu mesaj clar;
  • încercările greșite separate de un login reușit: contorul pornește de la zero;
  • durata: la 14 minute încă blocat, după 15 minute deblocat (aici e util un mediu în care se poate scurta durata prin configurare);
  • deblocarea prin resetarea parolei, dacă e permisă;
  • contorul e per cont, nu per browser: 3 încercări din Chrome și 2 din Firefox blochează contul;
  • email inexistent: mesajul e identic cu cel pentru parolă greșită, ca să nu se poată afla ce conturi există; tot așa, mesajul de blocare nu confirmă existența contului, dacă politica de securitate cere asta;
  • notificarea utilizatorului prin email la blocare, dacă e cerință;
  • încercări prin API, în afara interfeței, care trebuie numărate la fel.

„Ține-mă minte”:

  • fără bifă: după închiderea completă a browserului, utilizatorul trebuie să se logheze din nou (sau după expirarea sesiunii obișnuite);
  • cu bifă: rămâne logat după repornirea browserului, pentru perioada stabilită (de exemplu, 30 de zile);
  • logout-ul anulează și „ține-mă minte”;
  • schimbarea parolei pe alt dispozitiv invalidează sesiunile reținute;
  • pe un calculator partajat, utilizatorul își poate închide toate sesiunile din setările contului, dacă funcția există;
  • cookie-ul folosit are expirarea și atributele corecte, vizibile în DevTools.

Ce urmărește intervievatorul: Verifică dacă îmbini valorile limită cu securitatea pe un scenariu clasic. Greșeala tipică este să uiți resetarea contorului și mesajul pentru conturi inexistente.

89 Junior

Testează un automat de cafea. Cum îți structurezi răspunsul?

Răspuns scurt: Clarifici întâi cerințele (ce băuturi, ce plăți, cine îl folosește), apoi grupezi testele: funcționale (selecție, plată, rest, livrare), negative (fonduri insuficiente, lipsă ingrediente, anulare), nefuncționale (timp, utilizabilitate, accesibilitate, siguranță) și de întreținere (alimentare, curățare, erori).

Intervievatorul nu așteaptă o listă exhaustivă, ci o structură. Încep cu întrebări: ce băuturi oferă, cum se plătește (monede, card, aplicație), dă rest, unde e amplasat, cine îl folosește?

Apoi grupez testele:

Funcționale, drumul fericit:

  • aleg o cafea, plătesc suma exactă cu monede, primesc cafeaua corectă, în pahar, la temperatura potrivită;
  • plătesc cu mai mult și primesc restul corect;
  • plata cu cardul, contactless;
  • opțiuni: zahăr, lapte, intensitate.

Negative și de margine:

  • bani insuficienți, monede străine sau false, monede introduse după selecție;
  • anularea după introducerea banilor: restituirea integrală;
  • lipsă de pahare, apă, cafea sau monede pentru rest: aparatul anunță înainte de a încasa;
  • card refuzat, pierderea conexiunii la plata cu cardul;
  • apăsarea mai multor butoane simultan sau rapid, una după alta;
  • pană de curent în timpul preparării.

Nefuncționale:

  • timpul de preparare;
  • utilizabilitatea: instrucțiuni clare, afișaj lizibil, limba;
  • accesibilitatea: înălțimea butoanelor pentru o persoană în scaun cu rotile, braille, contrast;
  • siguranța: paharul nu se răstoarnă, lichidul fierbinte nu stropește;
  • igiena și condițiile de mediu (frig, căldură).

Operare și întreținere: alimentarea, curățarea, golirea monedelor, raportarea erorilor către operator, contorizarea vânzărilor.

La final prioritizez: încasarea fără livrare și restul greșit sunt cele mai grave, deci le testez primele.

Ce urmărește intervievatorul: Exercițiul clasic verifică structura gândirii și întrebările de clarificare. Greșeala tipică este să enumeri teste la întâmplare, fără grupare și fără prioritate.

90 Junior

Testează câmpul de căutare al unui magazin online.

Răspuns scurt: Verifici rezultatele relevante (potrivire exactă, parțială, majuscule, diacritice, greșeli de scriere, sinonime), căutarea fără rezultate, valori speciale (gol, spații, caractere speciale, text foarte lung), sugestiile automate, sortarea și filtrarea rezultatelor, performanța și siguranța câmpului.

Îmi organizez testele pe grupe.

Relevanța rezultatelor:

  • un nume exact de produs („cană albastră”) îl aduce primul;
  • căutare parțială („can”), după cod de produs, după marcă;
  • majuscule și minuscule tratate la fel;
  • diacritice: „cana” găsește „cană”, „Brasov” găsește „Brașov”, dacă așa e regula;
  • greșeli de scriere („cnaă”), plural și singular, sinonime, dacă motorul le suportă;
  • mai multe cuvinte, în altă ordine;
  • produsele fără stoc sau ascunse nu apar, sau apar marcate, conform regulii.

Fără rezultate: un mesaj clar și sugestii, nu o pagină goală sau o eroare.

Intrări speciale: câmp gol cu Enter, doar spații, un singur caracter, text foarte lung, caractere speciale (%, _, ', ", <, >), emoji, cifre. Caracterele % și _ sunt interesante pentru că au sens special în SQL (LIKE); un apostrof care produce eroare de server poate semnala o problemă de securitate. Introduc și <script> ca să văd dacă textul căutat, afișat în pagină („Rezultate pentru…”), e tratat ca text.

Sugestii automate: apar după câte caractere, se actualizează la tastare rapidă, se pot alege cu tastatura.

Pagina de rezultate: numărul de rezultate, paginarea, sortarea și filtrele aplicate peste căutare, URL-ul care păstrează căutarea (poate fi trimis cuiva), butonul Înapoi.

Nefuncțional: timpul de răspuns, nu se trimite câte un request la fiecare tastă fără întârziere (se vede în Network), funcționarea pe mobil și cu cititor de ecran.

Ce urmărește intervievatorul: Verifică dacă te gândești la relevanță, nu doar la „câmpul acceptă text”. Greșeala tipică este să uiți de diacritice, care contează mult pentru utilizatorii români.

Greșeala, în practică:Căutarea testată doar cu textul exact

91 Junior

Testează un câmp „Număr de telefon” într-un formular pentru clienți din România.

Răspuns scurt: Verifici formatele valide (07xx xxx xxx, +40 7xx, 0040, fix 021 sau 02xx), separatorii permiși (spații, puncte, cratime), lungimea exactă, prefixele invalide, litere și caractere speciale, câmpul gol, lipirea textului, tastatura numerică pe mobil și cum se salvează și se afișează numărul.

Mai întâi întreb: acceptăm doar mobil sau și fix? Doar numere românești sau și internaționale? Câmpul e obligatoriu? Cum se salvează (normalizat sau cum a fost scris)?

Presupunând că acceptăm mobil și fix românesc, partițiile:

Valide:

  • mobil național: 0722123456 (10 cifre, începe cu 07);
  • cu prefix internațional: +40722123456, 0040722123456;
  • cu separatori, dacă sunt permiși: 0722 123 456, 0722-123-456, 0722.123.456;
  • fix București: 0211234567; fix în alt județ, de exemplu Cluj: 0264123456.

Invalide:

  • 9 și 11 cifre (valori limită pe lungime);
  • prefixe care nu există (0122123456), prefixul +40 urmat de 0 (+400722123456), o greșeală foarte frecventă a utilizatorilor, care merită un mesaj util;
  • litere, + în interior, paranteze, dacă nu sunt permise;
  • gol, dacă e obligatoriu; doar spații;
  • număr străin (+44...), dacă nu e acceptat.

Comportament:

  • spațiile de la capete sunt eliminate;
  • lipirea unui număr copiat din altă aplicație, cu spații sau caractere invizibile;
  • pe mobil apare tastatura numerică (type="tel"), iar autocompletarea propune numărul utilizatorului;
  • mesajul de eroare spune formatul așteptat, cu exemplu;
  • salvarea: numărul e normalizat (de exemplu, +40722123456) și afișat consecvent în profil, factură și SMS-uri;
  • căutarea în administrare găsește clientul indiferent de formatul scris.

Pentru numere internaționale complete, echipa poate folosi o bibliotecă precum libphonenumber, iar atunci testez câteva țări reprezentative.

Ce urmărește intervievatorul: Verifică aplicarea claselor de echivalență pe un format real și local. Greșeala tipică este să tratezi telefonul ca pe un simplu număr de 10 cifre.

Greșeala, în practică:Testat doar un format validLitere netestate în câmpuri numerice

92 Junior

La interviu primești acces la o aplicație demo pe care nu ai văzut-o niciodată și 30 de minute ca să găsești și să raportezi probleme. Cum îți folosești timpul?

Răspuns scurt: Primele 5 minute faci un tur rapid ca să înțelegi scopul și fluxurile principale, apoi alegi 2–3 zone riscante și le explorezi cu tehnici rapide (limite, negative, stări), notând pe parcurs. Ultimele 8–10 minute le folosești pentru raportarea clară a celor mai importante probleme.

Exercițiul practic verifică felul în care lucrezi sub presiune, nu numărul de bug-uri. Planul meu:

Minutele 0–5, recunoaștere:

  • citesc ce mi se spune despre aplicație și întreb dacă există cerințe;
  • parcurg rapid paginile principale și notez fluxurile: înregistrare, căutare, coș, checkout, cont;
  • notez ce pare cel mai important pentru utilizator și cel mai riscant (bani, date personale).

Minutele 5–20, explorare țintită:

  • aleg 2–3 zone: de exemplu, coșul și checkout-ul, apoi formularul de înregistrare;
  • aplic rapid ce dă rezultate des: valori limită și negative în câmpuri, cantități, cupoane, dublu click, butonul Înapoi, reîncărcare, alt rol de utilizator, ecran îngust, Console și Network deschise;
  • notez fiecare problemă imediat, pe scurt (pagina, pașii, ce am văzut), și fac o captură; nu mă opresc să scriu raportul complet pentru fiecare.

Minutele 20–30, raportare:

  • aleg cele mai importante 4–6 probleme, ordonate după severitate;
  • le scriu cu titlu clar, pași, rezultat așteptat și obținut, mediu și severitate propusă;
  • adaug o listă scurtă cu alte observații și cu ce nu am apucat să testez.

Dacă intervievatorul e în cameră, gândesc cu voce tare: ce testez și de ce. Un raport cu cinci defecte bine scrise și prioritizate valorează mai mult decât 20 de rânduri neclare. La final pot spune ce aș testa în continuare dacă aș avea încă o oră.

Ce urmărește intervievatorul: Verifică organizarea timpului, prioritizarea și calitatea raportării. Greșeala tipică este să explorezi 29 de minute și să predai notițe greu de înțeles.

93 Junior

Product Owner-ul, care nu are pregătire tehnică, te întreabă: „Deci funcționalitatea a trecut testele, e fără probleme?” Cum îi explici ce înseamnă rezultatul testării?

Răspuns scurt: Îi explici pe limba lui ce s-a verificat, ce nu, ce probleme cunoscute rămân și ce risc presupune lansarea, fără să promiți „zero probleme”. Un răspuns structurat: ce am testat, ce am găsit, ce rămâne, recomandarea mea.

Răspunsul onest nu e nici „da, e perfectă”, nici o prelegere despre principiile testării. Îl structurez în patru părți scurte:

  • ce am verificat: „Am testat plata cu cardul și cu ramburs pe calculator și pe telefon, în browserele folosite de cei mai mulți clienți. Am încercat și situațiile în care cardul e refuzat sau clientul închide pagina.”
  • ce am găsit: „Am găsit 12 probleme. Cele 2 grave au fost reparate și verificate din nou. Rămân 3 minore, de exemplu un text aliniat greșit pe telefoanele mici.”
  • ce nu am verificat: „Nu am testat ce se întâmplă cu mii de clienți deodată, de asta se ocupă colegii de infrastructură. Plata prin transfer nu s-a modificat, așa că am verificat-o doar rapid.”
  • recomandarea și riscul: „Din punctul meu de vedere, se poate lansa. Riscul principal care rămâne e la plățile cu cardul pe telefoane mai vechi, pe care le-am testat mai puțin. Propun să urmărim plățile eșuate în primele zile.”

Ideea pe care o transmit, fără termeni tehnici: testarea reduce riscul, dar nu îl elimină; spun ce știm și ce nu știm, ca decizia de lansare să fie informată.

Ce evit: jargonul („regresia pe staging a trecut 94%”), promisiunea „nu are bug-uri” și opusul ei, un „nu garantez nimic” fără nicio recomandare. Un PO apreciază un tester care îi spune clar ce risc își asumă și îi propune o măsură concretă.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică dacă poți comunica rezultatele testării pentru decizii de business. Greșeala tipică este fie promisiunea „fără probleme”, fie un răspuns plin de jargon.

94 Junior

Descrie o zi obișnuită de lucru ca tester într-o echipă Scrum. Ce spui la daily stand-up?

Răspuns scurt: O zi tipică: daily, retestarea bug-urilor reparate, testarea story-urilor noi, discuții cu developerii și cu PO, scrierea sau actualizarea cazurilor de test, raportarea defectelor. La daily spui scurt ce ai testat, ce urmează și ce te blochează, cu accent pe riscurile pentru obiectivul sprintului.

O zi posibilă, cu variații de la o echipă la alta:

  • dimineața: verific ce s-a livrat pe mediul de test peste noapte, ce bug-uri au fost marcate reparate și ce mesaje au venit; îmi stabilesc prioritățile zilei;
  • daily stand-up (15 minute);
  • retestare: verific întâi bug-urile reparate, ca developerii să afle repede dacă au terminat;
  • testarea story-urilor din coloana „In Test”: criterii de acceptare, cazuri negative, explorare scurtă;
  • colaborare: întrebări către PO despre cazuri neclare, o sesiune de pair testing cu un developer, refinement pentru sprintul următor;
  • documentare: cazuri de test noi sau actualizate, rapoarte de bug, actualizarea suitei de regresie;
  • sfârșitul zilei: notez ce am terminat și ce rămâne, ca să pot raporta clar a doua zi.

La daily, nu citesc o listă de activități. Spun, pe scurt, ce contează pentru obiectivul sprintului:

Ieri: am terminat testarea story-ului cu cupoanele, are două
bug-uri minore raportate; am verificat reparația la SHOP-588.
Azi: încep checkout-ul pentru vizitatori și regresia pe coș.
Blocaj: mediul de curierat nu răspunde de ieri, deci 4 teste
de livrare sunt blocate. Am nevoie de cineva de la infrastructură.
Risc: story-ul de plăți a ajuns ieri la testare; dacă apar
probleme, nu termin regresia până vineri.

Detaliile tehnice le discut după daily, doar cu cei implicați. Blocajele le spun imediat, nu aștept daily-ul următor dacă e urgent.

Ce urmărește intervievatorul: Verifică dacă înțelegi ritmul real de lucru și dacă știi să comunici scurt și util. Greșeala tipică este un daily lung, cu detalii pe care nu le folosește nimeni.

95 Mid

Modelează un lift ca sistem cu stări și derivă testele din model. Ce stări, evenimente și tranziții invalide incluzi?

Răspuns scurt: Stări: oprit, uși deschise, uși în mișcare, urcă, coboară, urgență, mentenanță. Evenimente: apel de la etaj, comandă din cabină, obstacol la ușă, suprasarcină, alarmă. Tranziții invalide cheie: mișcare cu ușile deschise și deschiderea ușilor între etaje.

Pentru un lift, o listă liberă de teste scapă ușor din vedere combinațiile periculoase. Modelul cu stări face vizibile tranzițiile care nu trebuie să se întâmple niciodată.

Un model simplificat:

Stări: OPRIT_INCHIS, USI_SE_DESCHID, DESCHIS, USI_SE_INCHID,
       URCA, COBOARA, URGENTA, MENTENANTA
Evenimente: apel_etaj(n), comanda_cabina(n), sosire_etaj,
            obstacol_usa, suprasarcina, buton_alarma,
            pana_curent, cheie_mentenanta

Tranziții valide, exemple:

  • OPRIT_INCHIS + comanda_cabina(5) de la etajul 2 → URCA;
  • URCA + sosire_etaj(5) → OPRIT_INCHIS → USI_SE_DESCHID → DESCHIS;
  • USI_SE_INCHID + obstacol_usa → USI_SE_DESCHID;
  • DESCHIS + suprasarcina → rămâne DESCHIS, cu semnal;
  • orice stare + pana_curent → URGENTA (oprire, apoi coborâre controlată la cel mai apropiat etaj, dacă sistemul are asta).

Tranziții invalide, cele mai importante pentru siguranță:

  • URCA sau COBOARA cu ușile deschise sau în curs de deschidere;
  • deschiderea ușilor între etaje;
  • plecarea cu suprasarcină;
  • ieșirea din URGENTA fără intervenția unui operator;
  • comenzi de la etaje acceptate în MENTENANTA.

Din model derivez: un test pentru fiecare tranziție validă, încercări pentru fiecare tranziție invalidă, apoi secvențe (două apeluri în direcții opuse, apel la etajul curent, comandă spre același etaj de mai multe ori). Separat, testez algoritmul de deservire: ordinea în care sunt servite mai multe apeluri. Pentru un sistem real, testele de siguranță se fac după standardele din domeniu, de exemplu seria EN 81 în Europa.

Ce urmărește intervievatorul: Întrebarea clasică primește un unghi tehnic: verifică dacă poți aplica tranzițiile de stare la un sistem fizic. Greșeala tipică este să enumeri teste fără să separi tranzițiile periculoase.

Greșeala, în practică:Tranziții de stare invalide netestate

96 Mid

Testează funcționalitatea „Exportă comenzile în CSV” din panoul de administrare al unui magazin online.

Răspuns scurt: Verifici că fișierul conține exact comenzile filtrate, cu toate coloanele și valorile corecte, că se deschide corect în Excel (codificare, diacritice, separator, zecimale, date), că valorile cu virgule sau ghilimele nu strică structura, volumele mari, permisiunile și protecția împotriva formulelor injectate.

Împart testele pe trei niveluri: conținut, format, operare.

Conținutul:

  • exportul respectă filtrele aplicate (interval de date, status); compar numărul de rânduri cu cel afișat în listă;
  • limitele intervalului de date: comenzile din prima și ultima zi sunt incluse? În ce fus orar se face tăierea zilei?
  • fiecare coloană are valoarea corectă pentru câteva comenzi verificate manual (total, TVA, status, client);
  • export fără nicio comandă: fișier cu antet sau mesaj clar.

Formatul:

  • codificarea: diacriticele apar corect în Excel; un CSV în UTF-8 fără BOM e afișat des greșit în Excel pe Windows („Ä…” în loc de „ă”);
  • separatorul: în setările regionale românești, Excel așteaptă de obicei ; ca separator, pentru că virgula e separator zecimal; se decide formatul și se testează pe calculatorul utilizatorilor reali;
  • valorile care conțin separatorul, ghilimele sau rânduri noi (o adresă „Str. Mare, nr. 5”) sunt puse între ghilimele corect;
  • zecimalele, datele și numerele de telefon cu 0 în față (Excel poate elimina zeroul);
  • injectarea de formule: un client cu numele =HYPERLINK(...) sau care începe cu =, +, -, @ poate deveni formulă la deschiderea în Excel; exportul ar trebui să neutralizeze aceste valori (CSV injection, descris de OWASP).

Operare:

  • volum mare: zeci de mii de comenzi; exportul nu blochează pagina, are o limită sau rulează în fundal cu notificare;
  • permisiuni: doar rolurile autorizate pot exporta date personale; linkul de descărcare nu e accesibil fără autentificare;
  • numele fișierului conține data și e unic.

Ce urmărește intervievatorul: Verifică atenția la date și la integrarea cu unelte externe precum Excel. Greșeala tipică este să verifici doar că fișierul se descarcă.

97 Mid

Testează sistemul de plată al unei parcări cu barieră: iei bilet la intrare, plătești la automat, ieși cu biletul validat în maximum 15 minute de la plată.

Răspuns scurt: Identifici stările biletului (emis, plătit, expirat după plată, folosit) și regulile de tarif, apoi testezi limitele de timp (tariful la schimbarea orei, cele 15 minute după plată), plățile, biletele pierdute, defecțiunile și abuzurile, cum ar fi același bilet folosit de două ori.

Întreb întâi regulile: tariful (de exemplu, prima oră gratuită, apoi pe oră începută), plafonul zilnic, metodele de plată, ce se întâmplă cu biletul pierdut, programul.

Stările biletului: Emis → Plătit → Folosit la ieșire; Plătit → Expirat (după 15 minute fără ieșire) → trebuie plătită diferența; Emis → Pierdut. Testez fiecare tranziție și încercările invalide: ieșire cu bilet neplătit, a doua ieșire cu același bilet, plata unui bilet deja folosit.

Valori limită pe timp:

  • staționare de 59 și de 60 de minute, de 61 de minute (prima oră gratuită, apoi „oră începută”);
  • ieșire la 14 și la 16 minute după plată;
  • staționare peste miezul nopții, în zile diferite, la schimbarea orei de vară sau de iarnă;
  • plafonul zilnic atins.

Plata: monede, bancnote, card, rest corect, anularea plății, plata cu suma exactă, card refuzat, plată întreruptă de o pană de curent (biletul e marcat plătit sau nu?).

Bilete problematice: pierdut (tarif special, cum se dovedește ora intrării), deteriorat, introdus invers, bilet de la altă parcare.

Defecțiuni și siguranță: bariera nu coboară peste mașină (senzor), pana de curent cu mașini în interior, automatul fără rest, sistemul central offline (barierele funcționează cu cozi?), interfonul către operator.

Abuz: două mașini una după alta la o singură ridicare a barierei, același bilet folosit de două mașini.

Prioritizez după impact: blocarea ieșirii și siguranța mașinilor sunt cele mai grave, apoi încasările greșite.

Ce urmărește intervievatorul: Verifică dacă poți aplica stări și valori limită de timp pe un sistem fizic necunoscut. Greșeala tipică este să uiți de schimbarea orei și de biletul pierdut.

98 Mid

Un client sună la suport și spune că i s-a retras de două ori suma pentru o comandă. Bug-ul e în producție. Ce faci ca tester?

Răspuns scurt: Aduni rapid faptele (ID-ul comenzii, ora, metoda de plată, dispozitivul), verifici tranzacțiile în sistem și la procesatorul de plăți, încerci să reproduci pe mediul de test, raportezi cu prioritate maximă și ajuți la evaluarea impactului. Apoi propui testele care ar fi prins problema.

Un model de răspuns, pe pași:

  • înțeleg cazul concret, prin echipa de suport: ID-ul comenzii, ora, suma, metoda de plată, dispozitivul și browserul sau versiunea aplicației, ce a făcut clientul (a apăsat de două ori? i s-a părut că pagina nu răspunde?);
  • verific datele, fără să modific nimic în producție: în administrare, una sau două comenzi? În panoul procesatorului de plăți, două încasări sau o încasare și o pre-autorizare care se va anula singură? Distincția contează: o pre-autorizare blocată temporar nu e o încasare dublă;
  • evaluez impactul: e un caz izolat sau mai sunt clienți? Echipa tehnică poate căuta în date tiparul (aceeași sumă, același client, câteva secunde distanță);
  • raportez imediat pe canalul de incidente stabilit, cu severitate critică: ce știm, ce nu știm, câți clienți par afectați;
  • încerc să reproduc pe mediul de test: dublu click pe „Plătește”, reîncărcare în timpul plății, pierderea conexiunii, butonul Înapoi după 3D Secure, aceeași versiune de aplicație;
  • ajut la rezolvare: retestez reparația urgent, inclusiv variațiile, și verific că rambursarea clientului s-a făcut corect;
  • după incident: particip la analiza cauzei (post-mortem), fără căutarea vinovaților. Răspund cinstit la întrebarea „de ce nu am prins asta?” și propun teste noi: idempotența plății, dublu click, pierderea conexiunii, adăugate în regresie.

Clientul nu e al meu de gestionat direct; comunicarea o face suportul, dar eu le dau informațiile corecte și la timp.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică reacția calmă și structurată într-un incident real. Greșeala tipică este să intri în producție să „testezi” plăți sau să cauți vinovatul.

99 Senior

Cu o zi înainte de lansare, găsești un defect major: la clienții cu adrese de livrare în afara Bucureștiului, costul livrării apare 0. Product Owner-ul vrea să lanseze oricum. Ce faci?

Răspuns scurt: Prezinți clar faptele și impactul (ce clienți sunt afectați, cât ar putea costa, ce alternative există), propui opțiuni (reparație rapidă și retestare, lansare cu funcționalitatea dezactivată, lansare cu monitorizare), apoi respecți decizia celui responsabil, documentată în scris.

Testerul nu are, de obicei, dreptul de veto asupra lansării, dar are datoria de a face riscul vizibil și înțeles. Pașii mei:

  • verific faptele rapid: reproduc pe build-ul de lansare, delimitez problema (toate adresele din afara Bucureștiului? doar o anumită metodă de livrare? doar pe mobil?);
  • traduc defectul în impact de business: fiecare comandă din țară ar ajunge să fie livrată pe cheltuiala firmei; dacă există date despre ponderea acestor comenzi, le folosesc, fără să inventez cifre;
  • propun opțiuni, nu doar o problemă:
  • developerul estimează reparația; dacă e mică, o retestez imediat împreună cu regresia pe checkout;
  • lansarea cu funcționalitatea nouă dezactivată (feature flag) sau cu vechiul calcul al livrării;
  • lansarea cu o soluție temporară (cost fix de livrare pentru afara Bucureștiului) și monitorizare;
  • amânarea cu o zi;
  • cer decizia în scris: dacă PO decide să lanseze cu defectul, să fie consemnat în tichet sau în raportul de finalizare, cu riscul acceptat și cu planul de reparare;
  • escaladez doar dacă e cazul: dacă impactul e foarte mare și decidentul nu pare să înțeleagă riscul, îl implic pe managerul de produs sau pe cel de livrare, transparent și fără să ocolesc PO-ul.

După decizie, o susțin profesionist: pregătesc monitorizarea comenzilor din țară imediat după lansare și retestez reparația cu prioritate. Rolul meu e să mă asigur că decizia e luată informat, nu să câștig o dispută.

Ce urmărește intervievatorul: Întrebarea de senior verifică dacă poți influența o decizie dificilă cu fapte și opțiuni, păstrând relația. Greșeala tipică este fie tăcerea, fie blocarea lansării ca și cum testerul ar decide singur.

100 Senior

Echipa primește un tester junior. Cum îi faci onboarding-ul în primele două săptămâni, ca să devină util repede fără să fie copleșit?

Răspuns scurt: Planifici progresiv: întâi produsul și oamenii, apoi uneltele și procesul, apoi sarcini reale mici și sigure (retestări, cazuri existente), cu feedback zilnic pe rapoartele lui. În săptămâna a doua, primul story testat cap-coadă cu sprijin. Totul pe baza unui ghid scris, nu doar prin vorbă.

Un plan concret:

Zilele 1–2, contextul:

  • ce face produsul, pentru cine, care sunt fluxurile critice și ce înseamnă un incident grav pentru business;
  • echipa: cine e PO, cine lucrează la ce, pe ce canale se discută;
  • accesele: Jira, TestRail, mediile de test, conturile de test, aplicațiile mobile de test;
  • un tur al aplicației făcut împreună, apoi o oră de explorare liberă, cu notițe.

Zilele 3–5, uneltele și procesul, pe sarcini reale:

  • rulează cazuri de test existente din regresie, cu mine la dispoziție;
  • retestează bug-uri reparate (sarcină cu risc mic și cu feedback clar);
  • scrie primele rapoarte de bug; le citesc înainte de trimitere și discutăm ce se poate îmbunătăți (titlu, pași, rezultate);
  • participă la daily și la refinement, iar după fiecare îi explic ce s-a decis și de ce.

Săptămâna a doua, autonomie crescândă:

  • primește un story mic și îl testează complet: criterii de acceptare, cazuri, execuție, raportare;
  • facem împreună o sesiune exploratorie cu charter, apoi una o face singur;
  • la final, o discuție: ce a fost greu, ce lipsește din documentație.

Principii:

  • un ghid scris de onboarding (mediile, conturile, convențiile de raportare, contactele), pe care juniorul îl completează cu ce a lipsit;
  • feedback des și concret, pe muncă reală, fără critică în public;
  • încurajez întrebările, inclusiv cele „prostești”, și spun explicit că nimeni nu se așteaptă să știe totul.

Ce urmărește intervievatorul: Întrebarea de senior verifică abilitățile de mentorat și de organizare a cunoștințelor echipei. Greșeala tipică este „îi dau documentația și îl las să citească o săptămână”.

Întrebări de interviu pe meserie

Alte tehnologii

← 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 Testare manuală, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Testare manuală scriind cod, nu doar citind

Curs Testare manuală (QA): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 12 lecții sunt gratuite.