...
Pregătire interviuri

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

Întrebările despre Testare automată 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 Test Automation (Playwright și Selenium): primele 20 de lecții sunt gratuite.

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

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 142 minde citit
Întrebări de interviu Testare automată cu răspunsuri

La un interviu pentru un rol de QA Automation sau de SDET, testarea automată se verifică de obicei în trei feluri: întrebări de teorie despre unealtă („cum funcționează auto-waiting-ul”, „ce e o fixture”), fragmente de cod de test pe care trebuie să le citești și să spui ce e greșit, și live coding, în care scrii un test pentru un login, un coș sau un formular, de multe ori în Playwright sau Selenium cu JavaScript. Uneori primești o temă de casă: o mică suită pentru o aplicație demo, iar discuția de după pornește de la deciziile tale de structură.

La nivel de junior se urmărește dacă scrii teste corecte și stabile: locatori pe rol sau data-testid, aserțiuni care așteaptă singure, fără pauze fixe, teste independente și un Page Object simplu. La nivel de mid, întrebările merg spre fixtures, mock-uri de rețea, testare API, paralelizare, cauzele testelor instabile și rularea în CI. La senior apar strategia de automatizare, designul unei suite mari, migrarea între unelte și felul în care păstrezi încrederea echipei în pipeline.

Fiecare întrebare are un răspuns scurt, bun de spus în primele secunde, și unul detaliat, cu explicația și codul de care ai nevoie la întrebările de continuare. Exemplele folosesc JavaScript, ca în curs: @playwright/test pentru Playwright și selenium-webdriver cu Mocha pentru Selenium. Încearcă întâi să răspunzi singur, mai ales la întrebările cu cod, apoi compară și rulează exemplele pe o aplicație de test. Pentru teoria generală de QA, design de teste, SQL și Agile, vezi pagina de întrebări pentru meseria de QA Engineer.

Strategie și principii de automatizare

1 Junior

Ai un caz de test manual: „Utilizatorul se autentifică cu date valide și vede numele în antet”. Cum îl transformi într-un test automat Playwright?

Răspuns scurt: Păstrezi intenția, dar înlocuiești pașii vagi cu acțiuni precise pe locatori stabili și „rezultatul așteptat” cu aserțiuni explicite, care așteaptă singure starea paginii.

Un caz manual se bazează pe judecata testerului („verifică că totul arată bine”). Testul automat nu are judecată, deci fiecare pas și fiecare rezultat așteptat trebuie să devină ceva verificabil.

Pașii concreți:

  • precondițiile devin setup: utilizatorul de test există (creat prin API sau din datele de test), pagina de start e cunoscută;
  • fiecare acțiune devine un apel pe un locator robust (getByLabel, getByRole), nu pe coordonate sau clase CSS;
  • fiecare „rezultat așteptat” devine o aserțiune web-first;
  • datele (email, parolă) ies din test, în configurare sau într-un fișier de date.
JavaScript
import { test, expect } from '@playwright/test';

test('login valid afișează numele în antet', async ({ page }) => {
  await page.goto('/login');
  await page.getByLabel('Email').fill('ana@test.ro');
  await page.getByLabel('Parolă').fill(process.env.TEST_PASSWORD);
  await page.getByRole('button', { name: 'Autentificare' }).click();
  await expect(page).toHaveURL(/\/cont/);
  await expect(page.getByRole('banner')).toContainText('Ana');
});

Ce se pierde: observațiile întâmplătoare pe care un om le face din mers (un text trunchiat, o culoare ciudată). Ce se câștigă: aceeași verificare, rulată identic, la fiecare commit, în câteva secunde. De aceea automatizarea nu înlocuiește complet testarea exploratorie.

Ce urmărește intervievatorul: Se verifică dacă știi să traduci un pas vag într-o aserțiune precisă. Greșeala tipică este un test care face toți pașii, dar nu verifică nimic la final.

2 Junior

Ce înseamnă că testele automate trebuie să fie independente? Ce se întâmplă dacă testul B se bazează pe datele create de testul A?

Răspuns scurt: Fiecare test își pregătește singur starea de care are nevoie și poate rula singur, în orice ordine sau în paralel. Dacă B depinde de A, B pică atunci când A pică, e sărit sau rulează în alt worker.

Un test independent poate fi rulat izolat (npx playwright test -g "nume"), în orice ordine și în paralel cu altele, cu același rezultat. Pentru asta, își creează singur datele, nu lasă în urmă stare care să încurce alte teste și nu presupune că un alt test a rulat înainte.

Ce se strică atunci când B depinde de A:

  • dacă A pică, B pică și el, iar raportul arată două erori pentru un singur bug;
  • dacă rulezi doar B (de exemplu la depanare), pică fără motiv aparent;
  • cu paralelizare, A și B pot ajunge în workeri diferiți, iar ordinea nu mai e garantată;
  • la retry, B se reia singur, fără A.

În Playwright, izolarea este susținută de arhitectură: fiecare test primește un browser context nou, deci cookie-urile, localStorage și sesiunea nu trec dintr-un test în altul. Datele din backend însă nu sunt izolate automat, acolo e treaba ta.

Soluții practice: creezi datele în beforeEach sau într-o fixture (ideal prin API, rapid), folosești valori unice (un email cu sufix generat), iar curățenia o faci în teardown. Dacă un flux chiar are pași dependenți, îl scrii ca un singur test cu test.step, nu ca teste separate legate prin ordine.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi de ce suitele cu teste legate între ele devin imposibil de paralelizat și de depanat.

3 Junior

După ce criterii spui că un test automat este „bun”?

Răspuns scurt: Un test bun este determinist, rapid, independent, verifică un singur comportament, are un nume care spune ce verifică și, când pică, mesajul te duce direct la cauză.

Un test automat bun îndeplinește câteva criterii practice:

  • Determinist: pe același cod dă același rezultat. Un test care uneori trece și alteori nu scade încrederea în toată suita.
  • Independent: își pregătește singur datele și nu depinde de ordinea de rulare.
  • Focalizat: verifică un comportament. Dacă pică, știi ce s-a stricat fără să citești 40 de pași.
  • Citibil: numele descrie comportamentul („cuponul expirat afișează eroare”), nu implementarea („test3”). Un coleg trebuie să înțeleagă testul fără să ruleze aplicația.
  • Rapid: pregătește starea prin API sau cu sesiune salvată, nu prin click-uri repetate.
  • Robust la schimbări irelevante: folosește locatori pe rol, etichetă sau data-testid, nu pe structura DOM, și nu se strică dacă se schimbă o clasă CSS.
  • Diagnosticabil: aserțiuni cu mesaje clare, test.step pentru pași, trace și captură la eșec.
  • Util: poate pica. Un test fără aserțiuni relevante sau unul care verifică doar că pagina s-a încărcat dă o siguranță falsă.

Un mod simplu de a verifica ultimul punct: strică intenționat codul aplicației (sau schimbă valoarea așteptată) și vezi dacă testul pică. Dacă nu pică, nu testează ce crezi.

Ce urmărește intervievatorul: Se urmărește dacă ai un model mental al calității testelor, nu doar al acoperirii. Candidații uită adesea criteriul „testul trebuie să poată pica”.

4 Mid

Numește câteva anti-pattern-uri frecvente în automatizarea testelor și ce faci în locul lor.

Răspuns scurt: Cele mai dese sunt: pauze fixe, locatori legați de structura DOM, teste dependente între ele, login prin UI în fiecare test, aserțiuni lipsă sau prea vagi și retry-uri folosite ca să ascundă instabilitatea.

Anti-pattern-urile apar de obicei sub presiunea timpului și costă mult mai târziu:

  • Pauze fixe (waitForTimeout(3000)): testul e lent când aplicația e rapidă și pică atunci când e lentă. În loc: aserțiuni web-first sau așteptarea unui eveniment concret.
  • Locatori fragili (div > div:nth-child(3) > span): orice refactor de markup îi strică. În loc: getByRole, getByLabel, data-testid.
  • Teste înlănțuite prin ordine: unul pică, cad toate. În loc: fiecare test cu datele lui.
  • Setup prin UI peste tot: dacă 200 de teste fac login prin formular, suita e lentă și formularul de login devine punct unic de eșec. În loc: sesiune salvată sau login prin API.
  • Teste fără aserțiuni sau cu aserțiuni care trec mereu (expect(true).toBeTruthy()).
  • Testul-epopee: un singur test care parcurge toată aplicația. În loc: teste scurte, câte un comportament.
  • Retry ca soluție: un test care trece doar la a treia încercare ascunde o problemă reală, fie în test, fie în aplicație.
  • Logică complicată în teste (if, bucle care decid ce verifici): testul ajunge să aibă nevoie de propriile teste.
  • Duplicare: aceiași locatori copiați în 30 de fișiere, în loc de Page Object sau componente.

La interviu e bine să spui pentru fiecare și ce problemă concretă produce, nu doar că „nu e bine”.

Ce urmărește intervievatorul: Arată experiența practică: cine a întreținut o suită reală recunoaște imediat aceste probleme. Greșeala tipică este să enumeri fără să explici costul.

5 Mid

Ce este component testing în Playwright și când l-ai alege în locul unui test end-to-end?

Răspuns scurt: Component testing montează o singură componentă (React, Vue, Svelte) într-un browser real, fără restul aplicației. Îl alegi pentru stările și variantele unei componente, iar E2E pentru fluxurile care trec prin mai multe pagini și prin backend.

Playwright are un mod de testare a componentelor, distribuit ca pachete separate, de exemplu @playwright/experimental-ct-react. Este marcat încă experimental, deci API-ul se poate schimba între versiuni. Componenta este montată cu mount într-o pagină goală, servită de un bundler (Vite), iar testul folosește aceiași locatori și aceleași aserțiuni ca în E2E.

JavaScript
import { test, expect } from '@playwright/experimental-ct-react';
import CartBadge from './CartBadge';

test('badge-ul afișează 9+ peste 9 produse', async ({ mount }) => {
  const c = await mount(<CartBadge count={12} />);
  await expect(c).toHaveText('9+');
});

Când îl alegi:

  • componenta are multe stări (gol, eroare, încărcare, valori limită) greu de adus prin aplicația reală;
  • vrei feedback rapid și fără backend;
  • comportamentul ține de browser (focus, layout, evenimente) și un test unitar în jsdom nu e suficient de fidel.

Când rămâi la E2E: integrarea dintre componente, routing, autentificare, apeluri reale la API, adică ce poate pica doar cu aplicația completă.

Ca strategie, testele de componentă stau între testele unitare și cele E2E: preiau multe verificări de detaliu din UI, iar E2E rămâne pentru câteva fluxuri critice. Fișierele .jsx din exemplu cer configurarea de component testing (playwright-ct.config).

Ce urmărește intervievatorul: Verifică dacă știi că testarea UI nu înseamnă doar E2E și dacă poți alege nivelul potrivit. Mulți candidați nu știu că modul e experimental.

6 Mid

Testele E2E trebuie să treacă printr-un flux care trimite un email de confirmare și face o plată cu cardul. Cum tratezi aceste dependențe externe?

Răspuns scurt: Nu le chemi pe cele reale din producție. Folosești modurile de test ale furnizorilor (sandbox), servicii locale de captare a emailurilor sau mock-uri de rețea, și păstrezi un număr mic de teste de integrare reală pe un mediu dedicat.

Dependențele externe fac testele lente, instabile și uneori costisitoare. Strategia obișnuită are trei niveluri.

1. Mediul de test configurat corect. Aplicația de pe staging folosește cheile de test ale procesatorului de plăți (Stripe, de exemplu, are mod de test și carduri de test publicate), iar emailurile ajung într-un server SMTP de test (Mailpit, MailHog) sau într-un serviciu de inbox pentru teste, nu la oameni reali.

2. Verificarea efectului, nu a canalului. Pentru email, testul citește mesajul din API-ul serverului de test și extrage linkul de confirmare:

JavaScript
const res = await request.get(`${MAIL_API}/messages?to=${email}`);
const [msg] = await res.json();
const link = msg.body.match(/https?:\/\/\S+confirmare\S*/)[0];
await page.goto(link);

3. Mock pentru restul. Pentru stările greu de produs (plată refuzată, timeout la furnizor), interceptezi cererea cu page.route și întorci răspunsul dorit.

Pe lângă asta, ai câteva teste de integrare care trec chiar prin sandbox-ul furnizorului, rulate mai rar (nightly), ca să prinzi schimbările de contract. Iframe-urile de plată ale furnizorilor nu sunt sub controlul tău și se pot schimba, de aceea nu construiești sute de teste peste ele.

Niciodată: date de card reale, conturi reale sau chei de producție în teste.

Ce urmărește intervievatorul: Se verifică dacă știi să separi ce testezi tu de ce testează furnizorul. Greșeala tipică este să mock-uiești tot și să nu mai ai niciun test care trece prin integrarea reală.

7 Mid

Product ownerul îți cere să automatizezi în trei luni toate cele 600 de cazuri de test manuale ale echipei. Ce răspunzi?

Răspuns scurt: Nu refuzi, dar propui alt obiectiv: automatizezi întâi ce aduce valoare (fluxuri critice, regresie repetată, date multe), alegi nivelul potrivit pentru fiecare verificare și arăți progresul pe riscuri acoperite, nu pe număr de cazuri.

Un răspuns structurat:

Situația. Cererea pornește de la o nevoie reală (regresia manuală durează prea mult), dar „toate cele 600” nu este un obiectiv bun: unele cazuri sunt rare, unele sunt vizuale sau exploratorii, unele se testează mai ieftin la nivel de API sau unitar.

Ce faci concret.

  • Clasifici cazurile după risc și frecvență: fluxuri de bani și autentificare, funcționalități folosite zilnic, bug-uri care au revenit.
  • Pentru fiecare decizi nivelul: multe verificări de reguli (validări, calcule) merg în teste de API sau unitare, mult mai rapide și mai stabile decât UI.
  • Elimini sau comasezi cazurile duplicate și pe cele care nu mai corespund produsului.
  • Construiești întâi fundația (structură de proiect, Page Objects, date de test, rulare în CI), altfel primele sute de teste vor fi rescrise.
  • Livrezi incremental: după câteva săptămâni ai deja un smoke suite care rulează la fiecare PR.

Cum comunici. Propui un indicator diferit: ce fluxuri critice sunt acoperite automat și cât timp de regresie manuală s-a eliberat. Spui deschis că o suită mare scrisă în grabă devine instabilă și costă mai mult decât economisește.

Rezultatul. PO-ul primește ce își dorea de fapt (încredere la release, mai repede), iar tu eviți o suită imposibil de întreținut.

Ce urmărește intervievatorul: Întrebare de situație: se verifică dacă poți negocia obiective realiste și dacă înțelegi că nu orice caz manual merită automatizat la nivel de UI.

8 Senior

Cum îți dai seama dacă o suită de teste automate este „sănătoasă”? Ce urmărești în timp?

Răspuns scurt: Urmărești rata testelor instabile, durata suitei, timpul de reparare a testelor picate, bug-urile prinse înainte de release și cele scăpate, plus cât de des echipa ignoră un rezultat roșu.

O suită are valoare doar dacă echipa are încredere în ea. Câteva semnale merită urmărite constant, cu date reale din CI:

  • Teste instabile: câte teste au trecut doar la retry (Playwright le marchează flaky). Tendința crescătoare e primul semn de degradare.
  • Durata: timpul total și cele mai lente teste. O suită care crește în durată ajunge să fie rulată mai rar, deci prinde bug-urile mai târziu.
  • Timpul de la roșu la verde: cât stă un test picat până e reparat sau până e confirmat bug-ul.
  • Eșecuri după cauză: bug real în aplicație, problemă de test, problemă de mediu. Dacă majoritatea eșecurilor nu sunt bug-uri, suita produce zgomot.
  • Bug-uri scăpate în producție în zone considerate acoperite: arată unde testele există, dar verifică prost.
  • Testele care nu au picat niciodată de foarte mult timp: poate verifică ceva ce nu se schimbă sau au aserțiuni prea slabe.
  • Costul de întreținere: cât timp merge pe repararea testelor după schimbări de UI.

Instrumentele: raportul HTML și JUnit din CI, istoricul din servicii precum Allure sau dashboard-urile CI, plus o etichetare simplă a eșecurilor. Important e să nu transformi metricile în ținte („100% verde”), pentru că atunci oamenii încep să dezactiveze teste ca să atingă cifra.

Ce urmărește intervievatorul: Întrebare de senior: se verifică dacă tratezi suita ca pe un produs care trebuie întreținut. Greșeala tipică este să măsori doar numărul de teste.

Structura testelor și configurarea Playwright

9 Junior

Explică fiecare linie din testul următor.

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

test('pagina principală are titlul corect', async ({ page }) => {
  await page.goto('https://shoprapid.test/');
  await expect(page).toHaveTitle(/ShopRapid/);
});

Răspuns scurt: Se importă runner-ul (test) și aserțiunile (expect), se definește un test cu nume și o funcție asincronă care primește fixture-ul page, se deschide adresa și se verifică, cu reîncercare automată, că titlul conține „ShopRapid”.

Pe rând:

  • import { test, expect } from '@playwright/test' aduce runner-ul Playwright Test și funcția de aserțiuni extinsă cu matcheri pentru pagini și locatori.
  • test('...', async ({ page }) => { ... }) definește un test. Primul argument este numele, care apare în raport, deci trebuie să descrie comportamentul. Al doilea este o funcție async, pentru că aproape toate operațiile din browser sunt asincrone și întorc promisiuni.
  • { page } este destructurarea unui fixture: runner-ul creează pentru acest test un browser context nou și o pagină nouă, apoi le închide la final. Nu scrii tu launch sau close.
  • await page.goto(...) navighează și așteaptă implicit evenimentul load. Cu baseURL în config ai putea scrie doar page.goto('/').
  • await expect(page).toHaveTitle(/ShopRapid/) este o aserțiune web-first: reîncearcă până la expect.timeout (implicit 5 secunde) până când titlul se potrivește cu expresia regulată. Un regex înseamnă potrivire parțială; un string ar cere potrivire exactă.

await lipsă în fața unei acțiuni sau aserțiuni este o greșeală serioasă: promisiunea nu mai este așteptată, iar testul poate termina înainte ca verificarea să ruleze. Regula ESLint @typescript-eslint/no-floating-promises sau playwright/missing-playwright-await din pluginul ESLint pentru Playwright o prinde automat.

Ce urmărește intervievatorul: Verifică faptul că ai scris efectiv teste, nu doar ai citit despre ele. Mulți nu știu că { page } este un fixture creat per test.

Eroarea, în practică:ReferenceError: page is not defined

10 Junior

Care este diferența dintre browser, browserContext și page în Playwright?

Răspuns scurt: browser este procesul de browser pornit, browserContext este o sesiune izolată în el (cookie-uri, storage, permisiuni proprii, ca un profil incognito), iar page este un tab din acel context.

Ierarhia este browser → context → page.

  • Browser: instanța de Chromium, Firefox sau WebKit. Pornirea ei e relativ costisitoare, de aceea runner-ul o pornește o dată pe worker și o refolosește.
  • BrowserContext: o sesiune izolată, ca o fereastră incognito. Are propriile cookie-uri, localStorage, cache, permisiuni, geolocație, fus orar, viewport. Se creează foarte repede, de aceea fiecare test primește un context nou și pornește „curat”.
  • Page: un tab în context. Un context poate avea mai multe pagini, care împart aceeași sesiune (dacă te loghezi într-un tab, celălalt e și el logat).

Asta permite scenarii utile:

JavaScript
test('admin și client în paralel', async ({ browser }) => {
  const adminCtx = await browser.newContext({ storageState: 'auth/admin.json' });
  const clientCtx = await browser.newContext({ storageState: 'auth/client.json' });
  const admin = await adminCtx.newPage();
  const client = await clientCtx.newPage();
  // adminul schimbă prețul, clientul vede noul preț
  await adminCtx.close();
  await clientCtx.close();
});

Contextele create manual le închizi tu; cel din fixture-ul page este închis de runner.

În Selenium, echivalentul unui context nou ar fi, de regulă, o sesiune WebDriver nouă, adică un browser nou pornit. De aici o parte din diferența de viteză: izolarea per test e mult mai ieftină în Playwright.

Ce urmărește intervievatorul: Este o întrebare de arhitectură de bază. Greșeala tipică este să crezi că testele împart același browser și deci aceeași sesiune.

11 Junior

Cum rulezi doar o parte din teste în Playwright și cum le rulezi vizibil, pas cu pas?

Răspuns scurt: Filtrezi după fișier, linie, nume (-g) sau proiect (--project). Pentru vizibil folosești --headed, pentru pas cu pas --debug (Playwright Inspector), iar --ui deschide UI Mode, cu ceas de execuție și watch.

Comenzile folosite zilnic:

BASH
npx playwright test                          # toată suita
npx playwright test tests/cos.spec.js        # un fișier
npx playwright test tests/cos.spec.js:42     # testul de la linia 42
npx playwright test -g "cupon expirat"       # după numele testului (regex)
npx playwright test --grep-invert @lent      # exclude după text sau tag
npx playwright test --project=firefox        # doar un proiect din config
npx playwright test --headed                 # browser vizibil
npx playwright test --debug                  # Inspector, pas cu pas
npx playwright test --ui                     # UI Mode
npx playwright test --last-failed            # doar cele picate data trecută
npx playwright show-report                   # raportul HTML

Diferențele practice:

  • --headed doar arată browserul, testul rulează la viteză normală.
  • --debug deschide Playwright Inspector, setează timeout-urile la 0 și oprește înainte de fiecare acțiune; poți inspecta locatori și rula pas cu pas. În cod, await page.pause() oprește execuția în același mod.
  • --ui este cel mai comod la scrierea testelor: lista de teste, re-rulare la salvare, istoric de acțiuni cu DOM-ul din fiecare moment, rețea și consolă.

--last-failed există din versiunea 1.44. Pe CI nu folosești --headed sau --ui, ci headless, cu trace la eșec.

Ce urmărește intervievatorul: Verifică fluența cu unealta. Candidații care au lucrat doar prin tutoriale nu știu să ruleze un singur test sau să depaneze cu Inspector.

12 Junior

Care este diferența dintre test.skip, test.fixme, test.fail și test.only?

Răspuns scurt: skip sare testul (eventual condiționat), fixme îl sare marcându-l ca de reparat, fail îl rulează și se așteaptă să pice (bug cunoscut), iar only rulează doar testele marcate astfel, fiind folosit doar local.

Toate patru apar în raport diferit și au intenții diferite:

  • test.skip: testul nu rulează. Forma condiționată este cea mai utilă: test.skip(browserName === 'webkit', 'Upload-ul nu e suportat pe Safari'), apelată în corpul testului sau în beforeEach.
  • test.fixme: tot sărit, dar semnalează că testul e stricat și trebuie reparat. Diferența e de comunicare în raport.
  • test.fail: testul rulează și trebuie să pice. Dacă trece, Playwright îl raportează ca eșuat. Este potrivit pentru un bug cunoscut, raportat: când developerul îl repară, testul „pică” și îți amintește să scoți marcajul.
  • test.only: rulează doar testele marcate cu only. E comod local, dar periculos dacă ajunge în repository, pentru că CI-ul ar rula un singur test și ar raporta verde. De aceea în config se pune forbidOnly: !!process.env.CI.
JavaScript
test('totalul cu cupon cumulat', async ({ page }) => {
  test.fail(true, 'BUG-412: cupoanele se cumulează');
  // ...
});

test.describe('export PDF', () => {
  test.skip(({ browserName }) => browserName !== 'chromium', 'PDF doar în Chromium');
  // ...
});

Regula: un skip fără motiv și fără tichet devine test mort. Pune mereu motivul, care apare și în raport.

Ce urmărește intervievatorul: Se urmărește dacă știi să gestionezi bug-uri cunoscute fără să ștergi teste. Mulți nu știu că test.fail pică atunci când testul trece.

Eroarea, în practică:Expected to fail, but passed.item focused with '.only' is not allowed

13 Junior

Ce face page.goto și ce întoarce? Cum ai verifica că o pagină inexistentă întoarce 404?

Răspuns scurt: Navighează la adresă, așteaptă implicit evenimentul load și întoarce răspunsul principal (Response) sau null. Pentru 404 verifici response.status() și, separat, ce vede utilizatorul pe pagină.

page.goto(url, options) face navigarea și se rezolvă când pagina ajunge la starea din waitUntil: implicit load, alternativ domcontentloaded, commit sau networkidle (descurajat). Dacă în config ai baseURL, poți scrie căi relative: page.goto('/produse').

Valoarea întoarsă este un obiect Response pentru documentul principal (după redirecționări, ultimul). Poate fi null, de exemplu la navigarea doar pe ancoră în aceeași pagină.

Important: un status 404 sau 500 nu face goto să arunce eroare. Aruncă doar la erori de rețea (DNS, conexiune refuzată), la certificate invalide sau la timeout. Deci un test care doar face goto nu prinde o pagină de eroare.

JavaScript
test('produs inexistent întoarce 404 și pagina de eroare', async ({ page }) => {
  const response = await page.goto('/produs/nu-exista-12345');
  expect(response.status()).toBe(404);
  await expect(page.getByRole('heading', { name: 'Pagina nu a fost găsită' })).toBeVisible();
  await expect(page.getByRole('link', { name: 'Înapoi la magazin' })).toBeVisible();
});

Verifici ambele: statusul (important pentru SEO și pentru că un „soft 404”, adică pagină de eroare cu status 200, e un bug real) și conținutul (utilizatorul primește o pagină utilă, nu un ecran gol). Pentru aplicații SPA, ruta inexistentă poate întoarce 200 de la server, iar eroarea e randată de router, caz în care doar verificarea UI are sens.

Ce urmărește intervievatorul: Verifică dacă știi că goto nu eșuează la coduri HTTP de eroare. E o sursă de teste care trec deși pagina e stricată.

Eroarea, în practică:page.goto: Cannot navigate to invalid URLapiRequestContext.get: 404 Not Found

14 Junior

Ce este testInfo și la ce îl folosești într-un test sau într-un hook?

Răspuns scurt: testInfo este obiectul cu informații despre testul curent: nume, status, numărul încercării, timeout, căi de ieșire. Îl folosești ca să atașezi fișiere în raport, să faci acțiuni doar la eșec sau să adaptezi testul la retry.

Îl primești ca al doilea argument al testului sau al hook-urilor, sau prin test.info().

Câmpuri și metode utile:

  • testInfo.title, testInfo.project.name: pentru loguri sau nume de fișiere;
  • testInfo.status și testInfo.expectedStatus: în afterEach, afli dacă testul a picat neașteptat;
  • testInfo.retry: numărul încercării (0 la prima rulare);
  • testInfo.attach(nume, { body, contentType }) sau { path }: adaugă un atașament în raportul HTML;
  • testInfo.outputPath('fisier.json'): o cale unică pentru acest test, sigură la rulare în paralel;
  • testInfo.setTimeout(ms) sau test.slow(): mărește timeout-ul pentru un test lent;
  • testInfo.annotations: adnotări vizibile în raport.

Exemplu: la eșec, salvezi conținutul coșului citit din API, ca să ai contextul în raport.

JavaScript
test.afterEach(async ({ request }, testInfo) => {
  if (testInfo.status !== testInfo.expectedStatus) {
    const cos = await request.get('/api/cart');
    await testInfo.attach('cos-la-esec', {
      body: JSON.stringify(await cos.json(), null, 2),
      contentType: 'application/json',
    });
  }
});

Compari status cu expectedStatus, nu cu 'failed', pentru că un test marcat test.fail are expectedStatus egal cu 'failed', iar acolo un eșec este rezultatul corect.

Ce urmărește intervievatorul: Arată dacă știi să faci testele diagnosticabile. Greșeala tipică este scrierea fișierelor de debug pe căi fixe, care se suprascriu între workeri.

Eroarea, în practică:test.info() can only be called while test is running

15 Mid

Explică opțiunile principale dintr-un playwright.config.js tipic.

Răspuns scurt: Configul definește unde sunt testele, timeout-urile, paralelizarea, retry-urile, reporterii, opțiunile comune de browser din use (baseURL, trace, captură, video), proiectele (browsere sau dispozitive) și, opțional, serverul de pornit înainte de teste.

Un config realist:

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

export default defineConfig({
  testDir: './tests',
  timeout: 30_000,                 // per test (implicit 30 s)
  expect: { timeout: 5_000 },      // per aserțiune web-first (implicit 5 s)
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 2 : undefined,
  reporter: [['html', { open: 'never' }], ['junit', { outputFile: 'results.xml' }]],
  use: {
    baseURL: process.env.BASE_URL ?? 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
    testIdAttribute: 'data-testid',
  },
  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
  ],
  webServer: {
    command: 'npm run start',
    url: 'http://localhost:3000',
    reuseExistingServer: !process.env.CI,
  },
});

Ideile importante:

  • use la nivel de rădăcină se aplică tuturor proiectelor, iar use din proiect îl suprascrie.
  • timeout e bugetul întregului test, inclusiv hook-urile beforeEach/afterEach și fixture-urile; expect.timeout e doar pentru fiecare aserțiune care reîncearcă.
  • actionTimeout și navigationTimeout (în use) sunt implicit 0, adică fără limită proprie, limitate doar de timeout-ul testului.
  • Valorile diferite pentru CI (retries, workers, forbidOnly) se decid prin process.env.CI, setată automat de GitHub Actions.

Orice opțiune din use se poate schimba și pe un grup de teste cu test.use(...).

Ce urmărește intervievatorul: Verifică dacă ai configurat un proiect, nu doar ai rulat exemplul generat. Mulți confundă timeout-ul testului cu cel al aserțiunilor.

16 Mid

Cum testezi varianta mobilă a unui site cu Playwright? Ce emulează devices['iPhone 13'] și ce nu?

Răspuns scurt: Adaugi un proiect cu un descriptor din devices, care setează viewport, user agent, densitatea de pixeli, isMobile, hasTouch și browserul implicit. Nu primești însă un telefon real: nici iOS, nici Safari mobil exact, nici performanța sau tastatura dispozitivului.

Descriptorii din devices sunt seturi de opțiuni de context:

JavaScript
projects: [
  { name: 'desktop', use: { ...devices['Desktop Chrome'] } },
  { name: 'iphone', use: { ...devices['iPhone 13'] } },
  { name: 'android', use: { ...devices['Pixel 7'] } },
]

devices['iPhone 13'] conține un viewport de telefon, userAgent de iPhone, deviceScaleFactor, isMobile: true, hasTouch: true și defaultBrowserType: 'webkit'. Pagina vede deci un ecran îngust, media queries de mobil, evenimente touch și meta viewport respectat.

Ce poți testa bine: layout-ul responsive, meniul hamburger, elementele ascunse pe mobil, page.tap() și gesturi simple, comportamentul pe user agent mobil.

Ce nu e garantat:

  • WebKit-ul din Playwright e un build propriu, rulat pe Linux, Windows sau macOS, nu Safari pe iOS. Diferențele de randare și bug-urile specifice iOS pot lipsi.
  • Performanța, memoria, rețeaua mobilă reală (o poți doar aproxima).
  • Tastatura virtuală, zoom-ul nativ, notch-ul, comportamentul barei de adrese.

Practic: rulezi proiectul mobil pe fluxurile critice, cu teste care folosesc locatori comuni (getByRole funcționează la fel, chiar dacă meniul e altfel). Pentru încredere pe dispozitive reale, completezi cu ferme de dispozitive (BrowserStack, Sauce Labs) sau testare manuală pe câteva telefoane.

Ce urmărește intervievatorul: Verifică dacă știi limitele emulării. Greșeala tipică este să afirmi că proiectul WebKit „testează Safari pe iPhone”.

17 Mid

Cum folosești tag-urile și adnotările în Playwright ca să rulezi doar testele de smoke la fiecare pull request?

Răspuns scurt: Marchezi testele cu tag: '@smoke' (sau @smoke în titlu) și rulezi npx playwright test --grep @smoke. Adnotările (annotation) adaugă metadate, de exemplu linkul tichetului, vizibile în raport.

Din versiunea 1.42, tag-urile se dau explicit, în detaliile testului sau ale grupului:

JavaScript
test('login valid', { tag: ['@smoke', '@auth'] }, async ({ page }) => {
  // ...
});

test.describe('checkout', { tag: '@critic' }, () => {
  test('plată cu card de test', {
    annotation: { type: 'issue', description: 'https://jira.exemplu/SHOP-88' },
  }, async ({ page }) => {
    // ...
  });
});

Înainte de 1.42, convenția era tag-ul în titlu ('login valid @smoke'), încă suportată: --grep caută în titlu și în tag-uri.

Rulare:

BASH
npx playwright test --grep @smoke
npx playwright test --grep-invert @lent
npx playwright test --grep "@smoke|@critic"

Același filtru se poate pune în config, pe proiecte: un proiect smoke cu grep: /@smoke/ și unul regresie fără filtru.

Organizare practică într-un pipeline:

  • la fiecare PR: @smoke, câteva minute, un singur browser;
  • la merge în ramura principală sau nightly: suita completă, pe toate proiectele;
  • @lent sau @extern pentru testele care depind de servicii terțe, rulate separat.

Adnotările (issue, perf, tipuri proprii) nu filtrează, ci documentează: apar în raportul HTML și în testInfo.annotations, utile pentru legătura cu bug-urile cunoscute.

Ce urmărește intervievatorul: Arată că știi să organizezi suite pentru CI, nu doar să scrii teste. Mulți nu cunosc sintaxa nouă tag și încă pun etichetele doar în titlu.

Eroarea, în practică:Tag must start with "@" symbol

18 Mid

Ce face npx playwright codegen și de ce nu păstrezi codul generat exact cum e?

Răspuns scurt: Codegen deschide un browser, înregistrează ce faci și generează cod Playwright cu locatori recomandați. E util ca punct de plecare și pentru a găsi locatori, dar codul nu are structură, aserțiuni relevante, date parametrizate sau reutilizare.

npx playwright codegen https://shoprapid.test deschide un browser și fereastra Inspector. Fiecare click, tastare sau navigare devine o linie de cod, iar locatorii sunt aleși după aceleași priorități ca în recomandările oficiale: rol, text, etichetă, test id. Poți adăuga și aserțiuni simple din bara de unelte (vizibil, text, valoare). Opțiuni utile: --device="iPhone 13", --save-storage=auth.json pentru a salva sesiunea după login, --target pentru alt limbaj.

De ce nu îl lași așa:

  • Nu are intenție: înregistrează tot, inclusiv click-uri inutile, scroll-uri și focusări.
  • Aserțiuni puține sau irelevante: nu știe ce e important de verificat.
  • Date hardcodate: emailul și parola pe care le-ai tastat ajung în cod.
  • Fără structură: nu folosește Page Objects, fixtures sau pași reutilizabili, deci zece teste înregistrate repetă același login.
  • Locatori uneori slabi: pe pagini fără roluri și etichete bune, cade pe CSS sau pe texte lungi, care se schimbă.

Folosire bună: pentru a explora o pagină nouă, pentru a afla rapid locatorul unui element (butonul „Pick locator” din Inspector sau din UI Mode) și pentru a schița un flux, apoi rescrii testul curat. Dacă codegen nu găsește un locator bun, e un semnal că pagina are probleme de accesibilitate.

Ce urmărește intervievatorul: Se verifică dacă vezi diferența între înregistrare și automatizare. Greșeala tipică este o suită formată din scripturi înregistrate, imposibil de întreținut.

Locatori

Exersează capitolul cu exerciții reale: Curs testare automată →
19 Junior

Ce metode de localizare încorporate are Playwright și în ce ordine le preferi?

Răspuns scurt: Ordinea recomandată: getByRole, getByLabel, getByPlaceholder, getByText, getByAltText, getByTitle, apoi getByTestId. CSS și XPath prin page.locator rămân ultima variantă, pentru cazurile în care nimic altceva nu merge.

Ideea din spatele ordinii este să localizezi elementele cum le percepe utilizatorul, nu cum sunt scrise în cod:

  • getByRole('button', { name: 'Trimite' }): după rolul ARIA și numele accesibil. Prima alegere pentru butoane, linkuri, câmpuri, titluri, tabele, dialoguri.
  • getByLabel('Email'): câmpuri de formular după eticheta asociată (<label for>, aria-label, aria-labelledby).
  • getByPlaceholder('Caută produse'): când nu există etichetă (deja un mic semn de problemă de accesibilitate).
  • getByText('Coșul este gol'): elemente neinteractive cu text.
  • getByAltText('Logo ShopRapid'): imagini.
  • getByTitle('Șterge'): după atributul title.
  • getByTestId('cart-total'): după data-testid, contract explicit cu developerii.

De ce așa: un buton rămâne „buton cu numele Trimite” chiar dacă i se schimbă clasa, tag-ul (div cu role="button") sau poziția. În plus, dacă testul nu găsește elementul după rol și nume, adesea nici un cititor de ecran nu îl găsește, deci testul semnalează și o problemă de accesibilitate.

getByTestId e foarte stabil, dar nu verifică nimic despre ce vede utilizatorul, de aceea vine după cele semantice. Pentru texte care se traduc sau se schimbă des, poate fi totuși alegerea mai bună.

CSS (page.locator('.price')) și XPath sunt utile pentru structuri fără semantică, dar se leagă de implementare.

Ce urmărește intervievatorul: Se verifică dacă știi filozofia Playwright, nu doar sintaxa. Greșeala tipică este să pornești din reflex de la CSS copiat din DevTools.

Eroarea, în practică:check: Not a checkbox or radio button

20 Junior

Pagina are două butoane: „Adaugă” și „Adaugă în coș”. Ce găsește fiecare locator de mai jos?

JavaScript
page.getByRole('button', { name: 'Adaugă' });
page.getByRole('button', { name: 'Adaugă', exact: true });
page.getByRole('button', { name: /^adaugă în/i });

Răspuns scurt: Primul găsește ambele butoane (potrivirea implicită e parțială și ignoră majusculele), deci un click aruncă eroare de strict mode. Al doilea găsește doar „Adaugă”, iar al treilea doar „Adaugă în coș”.

Opțiunea name se potrivește cu numele accesibil al elementului: textul vizibil al butonului, sau aria-label, aria-labelledby, alt pentru imaginile din buton, title în ultimă instanță. Pentru un <input type="submit"> este value.

Regulile de potrivire pentru un string:

  • implicit: subșir, fără să conteze majusculele, cu spațiile normalizate;
  • exact: true: tot textul, cu majuscule exacte (spațiile de la capete tot se elimină);
  • regex: potrivire după expresie, aici ^adaugă în cu flag-ul i.

Deci:

  • { name: 'Adaugă' } se potrivește cu „Adaugă” și cu „Adaugă în coș”. Locatorul în sine e valid, dar click() va arunca strict mode violation, pentru că o acțiune cere exact un element.
  • { name: 'Adaugă', exact: true } ia doar butonul „Adaugă”.
  • regexul ia doar „Adaugă în coș”.

Dacă butonul conține doar o iconiță, numele accesibil vine din aria-label, iar getByRole('button', { name: 'Șterge' }) funcționează doar dacă developerul l-a pus. Dacă nu, merită cerut: e și un bug de accesibilitate.

Poți vedea numele accesibil în DevTools (panoul Accessibility) sau cu „Pick locator” din Inspector. getByRole mai acceptă opțiuni precum checked, disabled, expanded, level (pentru titluri) și pressed.

Ce urmărește intervievatorul: Verifică dacă știi regulile de potrivire ale lui name. Mulți presupun că potrivirea e exactă implicit și nu înțeleg de unde vine eroarea de strict mode.

Eroarea, în practică:strict mode violation: resolved to N elements

21 Junior

Când folosești getByTestId și cum schimbi atributul folosit de el?

Răspuns scurt: Îl folosești când elementul nu are un rol sau un text stabil (texte traduse, liste dinamice, iconițe) sau când vrei un contract explicit cu developerii. Atributul implicit e data-testid; îl schimbi cu testIdAttribute în config.

getByTestId('cart-total') caută [data-testid="cart-total"], cu potrivire exactă. Atributul există doar pentru teste, deci nu se schimbă la refactorizări vizuale și nu depinde de limbă.

Cazuri potrivite:

  • aplicații multilingve, unde textul diferă între rulări;
  • elemente fără semantică (un div cu totalul, un card dintr-o grilă);
  • componente unde numele accesibil se schimbă des (contoare, prețuri);
  • distincția între elemente identice vizual, de exemplu două liste cu același titlu.

Dezavantajul: nu verifică nimic din experiența utilizatorului. Un buton cu data-testid corect, dar fără text sau ascuns de alt element, poate trece testul de localizare. De aceea în multe echipe regula este: rol și etichetă unde se poate, test id unde e nevoie.

Schimbarea atributului, dacă proiectul folosește altă convenție:

JavaScript
// playwright.config.js
export default defineConfig({
  use: { testIdAttribute: 'data-qa' },
});

Bune practici: denumiri stabile și descriptive (product-card, nu div-12), coordonate cu developerii, eventual eliminate din build-ul de producție dacă echipa dorește (plugin-uri Babel sau SWC), deși de obicei se păstrează, fiindcă rulezi și teste pe un build apropiat de producție.

Combinat cu alți locatori: page.getByTestId('product-card').filter({ hasText: 'Tricou' }).getByRole('button', { name: 'Adaugă în coș' }).

Ce urmărește intervievatorul: Se urmărește dacă înțelegi compromisul dintre stabilitate și relevanța pentru utilizator. Greșeala tipică este fie să refuzi complet test id-urile, fie să le pui peste tot.

Eroarea, în practică:Unknown engine "testid" while parsing selector

22 Junior

Ce greșeli vezi în locatorii următori și cum i-ai rescrie?

JavaScript
await page.locator('#root > div > div:nth-child(3) > form > div:nth-child(2) > input').fill('ana@test.ro');
await page.locator('.btn.btn-primary.mt-2.px-4').click();
await page.locator('//div[3]/span[2]').click();

Răspuns scurt: Toți sunt legați de structura și stilul DOM-ului: se strică la orice wrapper nou, ordine schimbată sau clasă CSS modificată și nu spun nimic despre ce element e. Îi rescrii cu getByLabel, getByRole sau getByTestId.

Probleme, pe rând:

  • Primul selector descrie un drum prin DOM. Adaugi un div pentru layout sau muți un câmp mai sus și testul pică, deși aplicația funcționează. Nici nu știi din cod ce câmp completezi.
  • Al doilea folosește clase utilitare de stil (mt-2, px-4). Un designer schimbă spațierea și testul pică. Pe deasupra, pe pagină pot exista mai multe butoane cu aceleași clase, deci ajungi la strict mode violation.
  • Al treilea e un XPath absolut-poziționat: aceleași probleme ca primul, plus că e greu de citit.

Rescriere:

JavaScript
await page.getByLabel('Email').fill('ana@test.ro');
await page.getByRole('button', { name: 'Salvează' }).click();
await page.getByTestId('order-status').click();

Dacă elementele nu au etichetă, rol sau text, ai două variante corecte: ceri developerilor un data-testid (sau o etichetă reală, utilă și pentru accesibilitate), sau construiești un locator ancorat într-un element stabil: page.getByRole('row', { name: 'Comanda 1042' }).getByRole('button', { name: 'Detalii' }).

Regula de verificare: un locator bun trebuie să supraviețuiască unei refactorizări care nu schimbă comportamentul văzut de utilizator. Un selector copiat cu „Copy selector” din DevTools aproape niciodată nu trece testul ăsta.

Ce urmărește intervievatorul: Întrebare de cod: se verifică dacă recunoști imediat locatorii fragili. Candidații slabi apără selectorii generați automat pentru că „merg”.

23 Junior

Ce se întâmplă la rularea codului de mai jos dacă pe pagină sunt trei produse? Cum repari?

JavaScript
await page.getByRole('button', { name: 'Adaugă în coș' }).click();

Răspuns scurt: Testul pică cu eroarea „strict mode violation”, pentru că locatorul se rezolvă la trei elemente, iar o acțiune cere exact unul. Repari restrângând locatorul la cardul produsului dorit, nu cu .first() din reflex.

Locatorii Playwright sunt stricți: orice acțiune (click, fill, check) și majoritatea aserțiunilor pe un singur element aruncă eroare dacă locatorul găsește mai mult de un element. Mesajul arată ceva de genul „strict mode violation: getByRole('button', { name: 'Adaugă în coș' }) resolved to 3 elements” și listează elementele găsite.

E un comportament intenționat: în alte unelte, un selector ambiguu ia în tăcere primul element, iar testul apasă pe produsul greșit și trece sau pică din alt motiv.

Variante de reparare, de la cea mai bună:

JavaScript
// 1. restrângi la containerul relevant
await page.getByRole('listitem')
  .filter({ hasText: 'Tricou alb' })
  .getByRole('button', { name: 'Adaugă în coș' })
  .click();

// 2. un test id pe card
await page.getByTestId('product-tricou-alb')
  .getByRole('button', { name: 'Adaugă în coș' }).click();

// 3. poziție, doar dacă poziția face parte din cerință
await page.getByRole('button', { name: 'Adaugă în coș' }).first().click();

.first(), .last() și .nth(i) sunt legitime când chiar testezi ordinea („primul produs din listă după sortare”). Altfel, ascund ambiguitatea și se strică la orice schimbare de ordine.

Metodele care lucrează cu mai multe elemente sunt permise: count(), all(), allTextContents(), toHaveCount(), toHaveText([...]).

Ce urmărește intervievatorul: Verifică dacă înțelegi strict mode și de ce există. Greșeala tipică este .first() pus peste tot ca să „treacă testul”.

Eroarea, în practică:strict mode violation: resolved to N elementsexpect: strict mode violation (toHaveText)

24 Mid

Cum alegi butonul „Adaugă în coș” din cardul produsului care are textul „Tricou alb” și eticheta „Reducere”? Explică filter({ hasText }) și filter({ has }).

Răspuns scurt: Pornești de la cardurile de produs, le filtrezi după text cu hasText și după un element copil cu has, apoi cauți butonul în cardul rămas. Înlănțuirea restrânge căutarea la interiorul elementului anterior.

Locatorii se pot înlănțui: a.getByRole(...) caută doar în interiorul elementelor găsite de a. Peste asta, filter restrânge setul fără să coboare în DOM.

JavaScript
const card = page.getByTestId('product-card')
  .filter({ hasText: 'Tricou alb' })
  .filter({ has: page.getByText('Reducere', { exact: true }) });

await card.getByRole('button', { name: 'Adaugă în coș' }).click();
await expect(card.getByTestId('price')).toHaveText('49,99 lei');

Opțiunile filter:

  • hasText: elementul conține textul undeva în descendenți (subșir, fără majuscule) sau se potrivește cu un regex;
  • hasNotText: opusul;
  • has: conține un element care se potrivește cu locatorul dat, evaluat relativ la element (de aceea locatorul interior nu trebuie să înceapă din afara cardului);
  • hasNot: nu conține un astfel de element;
  • visible: true (din 1.51): doar elementele vizibile.

Mai există și combinarea la același nivel: a.and(b) (elementul trebuie să se potrivească cu ambii) și a.or(b) (oricare dintre ei), util de exemplu pentru „apare fie dialogul de cookie, fie pagina”: await expect(dialog.or(pagina).first()).toBeVisible().

Avantajul față de un XPath lung: fiecare pas e citibil, iar card se poate refolosi pentru mai multe acțiuni și verificări, inclusiv într-un Page Object.

Ce urmărește intervievatorul: Se verifică stăpânirea locatorilor compuși, esențiali pentru liste și grile. Mulți încearcă să rezolve totul cu un singur selector CSS lung.

25 Mid

Într-un tabel de utilizatori, scrie codul care apasă „Șterge” pe rândul cu emailul ana@test.ro și verifică faptul că rândul a dispărut.

Răspuns scurt: Iei rândul cu getByRole('row') filtrat după email, apeși butonul din acel rând, confirmi dialogul dacă există, apoi verifici cu toHaveCount(0) că rândul nu mai există, fără pauze.

Tabelele HTML corecte expun roluri: table, row, columnheader, cell. Un rând primește ca nume accesibil textul celulelor, deci poți filtra rândurile.

JavaScript
test('ștergerea unui utilizator din tabel', async ({ page }) => {
  await page.goto('/admin/utilizatori');

  const rand = page.getByRole('row').filter({ hasText: 'ana@test.ro' });
  await expect(rand).toHaveCount(1);

  page.once('dialog', dialog => dialog.accept());
  await rand.getByRole('button', { name: 'Șterge' }).click();

  await expect(rand).toHaveCount(0);
  await expect(page.getByRole('row').filter({ hasText: 'ion@test.ro' })).toHaveCount(1);
});

Detalii care contează:

  • Verifici întâi că rândul există exact o dată, altfel un test care șterge „nimic” ar putea trece.
  • Handler-ul de dialog se înregistrează înainte de click. Dacă aplicația folosește un dialog nativ confirm() și nu ai handler, Playwright îl închide automat (dismiss), iar ștergerea nu se face.
  • toHaveCount(0) reîncearcă până dispare rândul. Varianta expect(rand).not.toBeVisible() funcționează și ea.
  • Verificarea unui alt rând arată că nu s-a șters tot tabelul.

Pentru o celulă anume poți combina rândul cu indexul coloanei: rand.getByRole('cell').nth(2), dar indexul e fragil dacă se adaugă coloane. O variantă mai robustă e să afli indexul din antet după numele coloanei. Dacă tabelul e construit din div-uri fără roluri, folosești data-testid pe rânduri.

Ce urmărește intervievatorul: Întrebare de live coding frecventă. Se urmărește ancorarea în rând și verificarea dispariției fără waitForTimeout.

26 Mid

Când are sens XPath într-un test Playwright și de ce e, de regulă, evitat?

Răspuns scurt: XPath are sens când trebuie să urci în DOM sau să selectezi după relații pe care alte strategii nu le acoperă, în pagini fără semantică. E evitat pentru că e greu de citit, se leagă de structură și nu trece prin shadow DOM.

Playwright acceptă XPath prin page.locator('xpath=//...') sau direct orice șir care începe cu //. Poate exprima lucruri pe care CSS nu le poate ușor:

  • urcarea la părinte sau strămoș: //span[text()="Tricou alb"]/ancestor::article;
  • frații următori: //label[text()="Preț"]/following-sibling::input;
  • potrivirea textului exact al unui nod anume.

De ce îl eviți totuși:

  • Legat de structură: //div[2]/span[3] se strică la orice schimbare de markup.
  • Ilizibil pentru colegi, mai ales expresiile lungi cu contains și axe.
  • Nu pătrunde în shadow DOM, spre deosebire de locatorii CSS și de cei pe rol din Playwright, care trec prin shadow root-urile deschise.
  • Ignoră accesibilitatea: nu verifică ce percepe utilizatorul.

Aproape toate cazurile clasice se rezolvă mai curat cu locatori Playwright:

JavaScript
// XPath: //article[.//h3[text()="Tricou alb"]]//button[text()="Adaugă"]
page.getByRole('article')
  .filter({ has: page.getByRole('heading', { name: 'Tricou alb', exact: true }) })
  .getByRole('button', { name: 'Adaugă' });

// părinte direct, dacă chiar ai nevoie
page.getByText('Tricou alb').locator('..');

Unde XPath e încă acceptat: aplicații vechi fără etichete și fără roluri, unde nu poți cere test id-uri, sau migrarea graduală a unei suite Selenium. Și atunci, preferă expresii relative, ancorate într-un text stabil, nu căi absolute.

Ce urmărește intervievatorul: Verifică dacă îți cunoști opțiunile și le cântărești. Greșeala tipică este fie XPath peste tot, fie respingerea lui fără să știi ce oferă.

Eroarea, în practică:is not a valid XPath expression

27 Mid

Care este diferența dintre un Locator și un ElementHandle (page.$) în Playwright? De ce documentația recomandă locatorii?

Răspuns scurt: Un Locator este o descriere a elementului, rezolvată din nou la fiecare acțiune, cu auto-waiting și strict mode. Un ElementHandle este o referință la un nod DOM concret, care poate deveni învechită după re-randare și nu are auto-waiting pentru aserțiuni.

Diferența e între cum găsești un element și ce element anume ai găsit la un moment dat.

JavaScript
const buton = page.getByRole('button', { name: 'Salvează' }); // nu caută încă nimic
await buton.click();   // caută acum, așteaptă să fie acționabil, apasă
await buton.click();   // caută din nou, chiar dacă DOM-ul s-a schimbat

const handle = await page.$('button.save'); // caută acum, o singură dată
await handle.click();  // dacă butonul a fost re-randat, handle-ul e învechit

Avantajele locatorului:

  • Lazy și re-evaluat: în aplicațiile React sau Vue, elementele sunt adesea înlocuite la fiecare randare. Locatorul găsește mereu elementul curent, deci nu ai echivalentul lui StaleElementReferenceError din Selenium.
  • Auto-waiting: acțiunile așteaptă ca elementul să fie vizibil, stabil, activ.
  • Strict mode: eroare dacă găsește mai multe elemente, în loc să aleagă unul la întâmplare.
  • Aserțiuni web-first: expect(locator).toHaveText() reîncearcă; nu există echivalent pentru handle-uri.
  • Compozabil: filter, and, or, înlănțuire.

ElementHandle mai e folosit rar, de exemplu când ai nevoie de identitatea unui nod anume sau în cod vechi. Documentația îl descurajează, iar metodele page.$, page.$$, page.click(selector) sunt considerate API vechi față de locatori.

Un efect secundar: poți declara locatorii o singură dată, în constructorul unui Page Object, fără să-ți faci griji că pagina nu e încă încărcată.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului lazy, care explică mare parte din stabilitatea Playwright. Candidații care vin din Selenium tind să „caute elementul o dată și să-l țină”.

Eroarea, în practică:Cannot read properties of null (reading 'click')page.$eval: Failed to find element matching selector

28 Mid

Aplicația folosește Web Components cu shadow DOM. Cum localizezi un element din interiorul lor cu Playwright, dar cu Selenium?

Răspuns scurt: În Playwright, locatorii CSS, pe rol și pe text trec automat prin shadow root-urile deschise, deci scrii locatorul ca de obicei. În Selenium 4 obții shadow root-ul cu getShadowRoot() și cauți în el cu CSS; XPath nu funcționează în shadow DOM.

Shadow DOM încapsulează markup-ul unei componente: document.querySelector din afară nu vede elementele dinăuntru. Asta afectează testele în mod diferit.

Playwright: toți locatorii, cu excepția XPath, pătrund în shadow DOM deschis (mode: 'open'). Deci:

JavaScript
await page.getByRole('button', { name: 'Trimite' }).click();
await page.locator('my-cart-widget .total').textContent();

funcționează chiar dacă butonul și .total sunt în shadow root. Shadow DOM închis (mode: 'closed') nu e accesibil din exterior, din design.

Selenium WebDriver (JavaScript, versiunea 4):

JavaScript
const host = await driver.findElement(By.css('my-cart-widget'));
const root = await host.getShadowRoot();
const total = await root.findElement(By.css('.total'));
console.log(await total.getText());

În shadow root se pot folosi doar selectori CSS, nu XPath. Pentru componente imbricate repeți pașii pentru fiecare nivel, ceea ce face testele mai verbose; de aceea se ascunde de obicei într-o funcție ajutătoare sau într-un Page Object.

Capcana comună: cauți elementul în DevTools, copiezi un XPath și nu înțelegi de ce nu e găsit. Al doilea lucru de verificat: ce e în shadow DOM e adesea și într-un iframe (de exemplu widgeturi de plată), caz în care ai nevoie de frameLocator sau contentFrame() în Playwright și de switchTo().frame() în Selenium.

Ce urmărește intervievatorul: Întrebare de mid pentru aplicații moderne (design systems pe Web Components). Se verifică dacă știi că XPath nu funcționează aici.

Așteptări și sincronizare

29 Junior

Ce verifică Playwright înainte de un click() și ce face opțiunea force: true?

Răspuns scurt: Înainte de click, Playwright așteaptă ca elementul să fie atașat, vizibil, stabil (fără animație), să primească evenimente (nu e acoperit de alt element) și să fie activ. force: true sare peste verificările neesențiale, de obicei ascunzând un bug sau o problemă de test.

Aceste verificări se numesc actionability checks, iar fiecare acțiune are setul ei:

  • click, dblclick, check, hover: elementul trebuie să fie vizibil, stabil, să primească evenimente; pentru click și check și activ (enabled);
  • fill, clear: vizibil, activ, editabil (nu readonly);
  • selectOption: vizibil și activ;
  • scrollIntoViewIfNeeded, screenshot: vizibil și stabil.

„Stabil” înseamnă că elementul are aceeași poziție în două cadre de animație consecutive. „Primește evenimente” înseamnă că punctul de click nu e acoperit de alt element, de exemplu un overlay de încărcare sau bannerul de cookie. Dacă o verificare nu trece, Playwright reîncearcă până la timeout, iar eroarea finală spune exact care verificare a eșuat („element is not visible”, „subtree intercepts pointer events”).

JavaScript
// Greșit: ascunde problema
await page.getByRole('button', { name: 'Plătește' }).click({ force: true });

// Corect: aștepți să dispară ce acoperă butonul
await expect(page.getByTestId('loading-overlay')).toBeHidden();
await page.getByRole('button', { name: 'Plătește' }).click();

force: true face click chiar dacă un element acoperă butonul. Utilizatorul real nu poate face asta, deci testul trece pe o pagină pe care omul nu poate plăti. Există cazuri rare legitime (un input ascuns stilizat cu o etichetă vizibilă), dar și acolo e mai bine să dai click pe eticheta vizibilă.

Ce urmărește intervievatorul: Verifică dacă știi concret ce înseamnă auto-waiting, nu doar că „Playwright așteaptă singur”. Greșeala tipică este force: true ca primă soluție la un click care pică.

Eroarea, în practică:element is not visibleelement is not enabled

30 Junior

De ce e greșit testul următor și cum l-ai rescrie?

JavaScript
await page.getByRole('button', { name: 'Caută' }).click();
await page.waitForTimeout(3000);
const n = await page.getByTestId('product-card').count();
expect(n).toBe(4);

Răspuns scurt: Pauza fixă face testul lent când rezultatele vin repede și instabil când vin în peste 3 secunde, iar count() citește o valoare de moment. Rescris: await expect(page.getByTestId('product-card')).toHaveCount(4), care reîncearcă până se potrivește.

Problemele, separat:

  • waitForTimeout(3000) presupune că rezultatele vin mereu în mai puțin de 3 secunde. Local merge, pe un runner CI încărcat sau cu un backend mai lent pică. Iar când răspunsul vine în 200 ms, testul pierde degeaba aproape 3 secunde; înmulțit cu sute de teste, suita devine considerabil mai lentă.
  • count() întoarce numărul de elemente în acel moment. Dacă lista încă se actualizează (de exemplu afișează întâi rezultatele vechi, apoi pe cele noi), citești o valoare intermediară.
  • expect(n).toBe(4) este o aserțiune pe o valoare simplă, fără reîncercare.

Varianta corectă:

JavaScript
await page.getByRole('button', { name: 'Caută' }).click();
await expect(page.getByTestId('product-card')).toHaveCount(4);

toHaveCount reîncearcă până la expect.timeout (implicit 5 secunde): trece în momentul în care sunt 4 carduri și pică doar dacă nu ajunge niciodată la 4.

Dacă lista poate avea un număr corect intermediar (vechile rezultate erau tot 4), aștepți un semnal clar al finalizării: dispariția indicatorului de încărcare, textul „4 rezultate pentru «tricou»” sau răspunsul cererii de căutare cu waitForResponse.

Documentația Playwright descurajează explicit waitForTimeout în teste; el rămâne util doar la depanare, pentru a observa pagina.

Ce urmărește intervievatorul: Este probabil cea mai frecventă întrebare de cod la interviurile de automatizare. Se urmărește dacă recunoști atât pauza fixă, cât și citirea unei valori de moment.

Eroarea, în practică:expect(received).toHaveLength(expected)

31 Junior

Ce timeout-uri există în Playwright Test și ce valori implicite au?

Răspuns scurt: Timeout-ul testului (implicit 30 de secunde, include hook-urile și fixture-urile), timeout-ul aserțiunilor expect (implicit 5 secunde), plus actionTimeout și navigationTimeout (implicit fără limită proprie) și globalTimeout pentru toată rularea (implicit dezactivat).

Timeout-urile sunt imbricate, iar mesajul de eroare spune care a expirat:

  • Test timeout (timeout în config, implicit 30 000 ms): bugetul unui test, inclusiv beforeEach, afterEach și fixture-urile cu scop de test. Mesaj: „Test timeout of 30000ms exceeded”.
  • Expect timeout (expect: { timeout }, implicit 5 000 ms): cât reîncearcă o aserțiune web-first. Mesaj: „Timed out 5000ms waiting for expect(locator).toHaveText(expected)”.
  • Action timeout (use: { actionTimeout }, implicit 0): limita pentru click, fill etc. Cu 0, acțiunea așteaptă până expiră timeout-ul testului.
  • Navigation timeout (use: { navigationTimeout }, implicit 0): pentru goto, waitForURL.
  • Global timeout (globalTimeout, implicit 0): pentru toată rularea, util pe CI ca plasă de siguranță.
  • Fixture-urile cu scop de worker și beforeAll au timeout-uri separate.

Ajustări locale:

JavaScript
test('export raport mare', async ({ page }) => {
  test.slow();                                  // triplează timeout-ul testului
  await page.getByRole('button', { name: 'Exportă' }).click();
  await expect(page.getByText('Export finalizat'))
    .toBeVisible({ timeout: 20_000 });          // doar pentru această aserțiune
});

Practica bună: setezi actionTimeout la o valoare rezonabilă (de exemplu 10 secunde), ca un click blocat să pice cu mesaj clar despre acel element, nu ca timeout generic de test. Mărirea timeout-ului global ca să „treacă testele” e un semnal de alarmă: de obicei ascunde o așteptare greșită sau o aplicație lentă.

Ce urmărește intervievatorul: Se verifică dacă poți interpreta corect un mesaj de timeout. Greșeala tipică este să crezi că expect așteaptă cât timeout-ul testului.

Eroarea, în practică:Test timeout of 30000ms exceededlocator.click: Timeout 30000ms exceeded

32 Mid

Vrei să verifici că după click pe „Salvează” aplicația trimite cererea către /api/profile și primește 200. Ce e greșit în codul de mai jos?

JavaScript
await page.getByRole('button', { name: 'Salvează' }).click();
const response = await page.waitForResponse('**/api/profile');
expect(response.status()).toBe(200);

Răspuns scurt: Există o condiție de cursă: răspunsul poate sosi înainte ca waitForResponse să înceapă să asculte, iar testul expiră. Pornești așteptarea înainte de click, păstrezi promisiunea și o aștepți după.

waitForResponse ascultă doar răspunsurile care sosesc după apelul lui. Dacă cererea e rapidă (sau e servită din mock), răspunsul vine în timp ce click() se încheie, iar ascultătorul pornit ulterior nu îl mai vede. Rezultatul e un test intermitent: trece când serverul e lent și pică când e rapid.

Forma corectă:

JavaScript
const responsePromise = page.waitForResponse(
  r => r.url().includes('/api/profile') && r.request().method() === 'PUT'
);
await page.getByRole('button', { name: 'Salvează' }).click();
const response = await responsePromise;

expect(response.status()).toBe(200);
expect(await response.json()).toMatchObject({ name: 'Ana Pop' });
await expect(page.getByText('Profil salvat')).toBeVisible();

Observații:

  • Promisiunea se creează fără await, apoi se așteaptă după acțiune. Alternativ, Promise.all([page.waitForResponse(...), buton.click()]).
  • Un predicat (funcție) e mai precis decât un glob: filtrezi după metodă, după parametri sau după body, ca să nu prinzi un GET la aceeași adresă.
  • Același tipar se aplică la waitForRequest, waitForEvent('download'), waitForEvent('popup'), context.waitForEvent('page').
  • Verifici și efectul în UI. Un răspuns 200 nu garantează că utilizatorul vede confirmarea.

waitForResponse are și el timeout (implicit cel de navigare sau al testului), deci un predicat greșit duce la un timeout, nu la un test trecut din greșeală.

Ce urmărește intervievatorul: Clasică pentru mid: se verifică înțelegerea ordinii evenimentelor asincrone. Mulți scriu așteptarea după acțiune și nu înțeleg de ce testul e instabil.

Eroarea, în practică:waitForResponse: Timeout while waiting for event

33 Mid

După un click pe „Autentificare”, aplicația redirecționează spre /cont. Cum aștepți corect navigarea și de ce nu mai folosești waitForNavigation?

Răspuns scurt: Folosești await expect(page).toHaveURL(/\/cont/) sau await page.waitForURL('**/cont'), apelate după click. waitForNavigation e marcat deprecated pentru că are condiții de cursă și nu funcționează bine cu navigările din SPA.

page.waitForNavigation() aștepta „următoarea navigare”. Trebuia pornit înainte de click (altfel rata navigarea), nu știa care navigare e cea dorită (un redirect intermediar o satisfăcea) și în aplicațiile SPA, unde ruta se schimbă prin history.pushState, comportamentul era confuz. De aceea e deprecated.

Variantele moderne așteaptă o stare, nu un eveniment, deci nu contează dacă navigarea a avut loc deja:

JavaScript
await page.getByRole('button', { name: 'Autentificare' }).click();

// aserțiune web-first: reîncearcă până la expect.timeout
await expect(page).toHaveURL(/\/cont$/);

// sau așteptare explicită, cu opțiuni de încărcare
await page.waitForURL('**/cont', { waitUntil: 'domcontentloaded' });

Diferențe practice:

  • toHaveURL e o aserțiune: dacă URL-ul nu se potrivește, testul pică cu mesaj clar (așteptat vs primit).
  • waitForURL e o așteptare: e potrivită ca pas de sincronizare, de exemplu într-o metodă de Page Object login() care trebuie să se întoarcă doar după ce ești în cont. Acceptă string cu glob, regex sau funcție, și poate aștepta și load.

Pentru robustețe verifici și ce vede utilizatorul după navigare, de exemplu titlul paginii de cont. Un URL corect cu un mesaj de eroare pe pagină e tot un bug. Pentru căi care conțin ID-uri variabile, un regex (/\/comenzi\/\d+$/) e mai bun decât un string exact.

Ce urmărește intervievatorul: Se verifică dacă ești la curent cu API-ul actual și înțelegi diferența dintre a aștepta un eveniment și a aștepta o stare.

Eroarea, în practică:page.waitForURL: Timeout exceededexpect(page).toHaveURL(expected) failed

34 Mid

Când ai nevoie de locator.waitFor() dacă acțiunile și aserțiunile au deja auto-waiting?

Răspuns scurt: Rar: când vrei să aștepți o stare fără să faci o acțiune sau o aserțiune, de exemplu în cod de sincronizare dintr-un Page Object sau înainte de o operație fără auto-waiting, precum count(), allTextContents() sau evaluate.

waitFor({ state, timeout }) așteaptă ca locatorul să ajungă într-una din stările:

  • attached: elementul există în DOM;
  • detached: elementul nu mai există;
  • visible (implicit): există și e vizibil;
  • hidden: nu există sau nu e vizibil.

Unde e util:

  • Înaintea metodelor fără auto-waiting. count(), allTextContents(), all(), isVisible() și evaluate() întorc imediat valoarea curentă. Dacă vrei lista de prețuri după încărcare, aștepți întâi un element din ea:
JavaScript
const preturi = page.getByTestId('price');
await preturi.first().waitFor();
const texte = await preturi.allTextContents();
  • Sincronizare în Page Object, unde nu vrei aserțiuni: metoda open() se încheie după ce loading a dispărut, cu await this.spinner.waitFor({ state: 'hidden' }).
  • Elemente care apar și dispar, ca un toast: aștepți visible, apoi hidden.

Când nu ai nevoie: înaintea lui click() sau fill() (le face oricum) și înaintea unei aserțiuni web-first (toBeVisible deja așteaptă). await x.waitFor(); await expect(x).toBeVisible(); e redundant.

Capcana: isVisible() nu așteaptă. Codul if (await banner.isVisible()) await inchide.click() verifică un singur moment, deci rezultatul depinde de cât de repede s-a încărcat pagina. Pentru elemente care apar imprevizibil, cum e bannerul de cookie, Playwright are page.addLocatorHandler() (din 1.42), care îl închide automat ori de câte ori blochează o acțiune.

Ce urmărește intervievatorul: Verifică dacă știi exact care metode așteaptă și care nu. Greșeala tipică este isVisible() folosit ca și cum ar aștepta.

Eroarea, în practică:page.waitForSelector: Timeout exceeded

35 Mid

Câmpul de căutare are debounce: cererea pleacă abia la 300 ms după ultima tastă. Cum testezi rezultatele fără pauze fixe?

Răspuns scurt: Tastezi textul, apoi aștepți fie răspunsul cererii de căutare cu waitForResponse pornit înainte de tastare, fie direct starea finală a listei cu aserțiuni web-first. Pentru a verifica debounce-ul în sine, numeri cererile trimise.

Debounce înseamnă că aplicația amână acțiunea până când utilizatorul se oprește din tastat pentru un interval. Testul nu trebuie să știe de interval, ci doar de rezultat.

Varianta simplă, suficientă de obicei:

JavaScript
await page.getByRole('searchbox', { name: 'Caută' }).fill('tricou');
await expect(page.getByTestId('product-card')).toHaveCount(3);
await expect(page.getByTestId('product-card').first()).toContainText(/tricou/i);

Aserțiunea reîncearcă până la 5 secunde, mult peste cele 300 ms ale debounce-ului.

Dacă lista avea deja 3 rezultate înainte (risc de a citi starea veche), te sincronizezi pe cerere:

JavaScript
const raspuns = page.waitForResponse(r => r.url().includes('/api/search?q=tricou'));
await page.getByRole('searchbox', { name: 'Caută' }).fill('tricou');
await raspuns;
await expect(page.getByTestId('product-card')).toHaveCount(3);

Testarea comportamentului de debounce (că nu pleacă o cerere la fiecare literă):

JavaScript
const cereri = [];
page.on('request', r => { if (r.url().includes('/api/search')) cereri.push(r.url()); });
await page.getByRole('searchbox', { name: 'Caută' }).pressSequentially('tricou', { delay: 50 });
await expect.poll(() => cereri.length).toBe(1);

fill setează valoarea dintr-o dată, deci nu simulează tastarea. pressSequentially (fostul type) trimite literele una câte una, ca un om. Pentru control total asupra timpului, page.clock poate avansa ceasul paginii fără să aștepți real.

Ce urmărește intervievatorul: Scenariu din aplicații reale: se urmărește sincronizarea corectă pe rezultat sau pe rețea. Mulți răspund cu waitForTimeout(500).

36 Mid

Care este diferența dintre expect.poll și expect(...).toPass()? Dă câte un exemplu.

Răspuns scurt: expect.poll reapelează o funcție care întoarce o valoare și aplică un matcher pe ea până trece. toPass reîncearcă un bloc întreg de cod, cu oricâte aserțiuni și acțiuni, până nu mai aruncă eroare.

Ambele aduc reîncercarea, specifică aserțiunilor web-first, în situații unde nu ai un locator.

expect.poll: pentru o valoare care se schimbă în timp, de exemplu starea unei comenzi citită din API:

JavaScript
await expect.poll(async () => {
  const res = await request.get(`/api/orders/${id}`);
  return (await res.json()).status;
}, {
  message: 'comanda ar trebui să ajungă în starea paid',
  timeout: 15_000,
  intervals: [500, 1_000, 2_000],
}).toBe('paid');

Funcția e chemată repetat, iar matcherul (toBe, toEqual, toBeGreaterThan) se aplică pe rezultat. Timeout-ul implicit e expect.timeout.

toPass: pentru un grup de pași care trebuie reluat împreună:

JavaScript
await expect(async () => {
  await page.getByRole('button', { name: 'Reîncarcă' }).click();
  await expect(page.getByTestId('stock')).toHaveText('În stoc', { timeout: 1_000 });
}).toPass({ timeout: 20_000, intervals: [1_000, 2_000] });

Important: toPass nu folosește expect.timeout; implicit are timeout 0, adică reîncearcă până la timeout-ul testului, deci pune mereu un timeout explicit. Aserțiunile din interior au nevoie de timeout scurt, altfel o singură încercare consumă tot bugetul.

Ambele sunt pentru procese asincrone reale (joburi, cozi, replicare). Dacă le folosești pentru un element din pagină, aproape sigur ai fi putut folosi o aserțiune pe locator.

Ce urmărește intervievatorul: Întrebare de mid care separă candidații care au lucrat cu procese asincrone. Greșeala tipică e toPass fără timeout explicit.

Eroarea, în practică:expect.poll: waiting on the predicate

37 Mid

Un coleg pune await page.waitForLoadState('networkidle') după fiecare goto, „ca să fie sigur că pagina s-a încărcat”. Ce îi spui?

Răspuns scurt: Că networkidle (nicio cerere timp de 500 ms) e descurajat de documentație: e lent, nu garantează că UI-ul e gata și poate să nu se atingă deloc pe pagini cu polling, analytics sau websockets. Mai bine aștepți elementul sau răspunsul de care testul are nevoie.

waitForLoadState acceptă trei stări: load (implicit pentru goto), domcontentloaded și networkidle. Ultima se consideră atinsă când nu a existat nicio cerere de rețea timp de cel puțin 500 ms.

De ce e o problemă:

  • Nu înseamnă „pagina e gata”. Un SPA poate termina cererile și apoi să mai randeze câteva sute de milisecunde, sau poate porni o cerere nouă după un setTimeout.
  • Poate să nu se atingă niciodată: pagini cu polling, chat, analytics, reclame, websockets. Testul expiră fără ca aplicația să aibă vreo problemă.
  • Adaugă timp mort la fiecare navigare, cel puțin jumătatea de secundă de liniște.
  • Ascunde intenția: nu reiese ce element sau date așteaptă de fapt testul.

Alternativa este să aștepți semnalul relevant pentru test:

JavaScript
await page.goto('/produse');
await expect(page.getByRole('heading', { name: 'Produse' })).toBeVisible();
await expect(page.getByTestId('product-card')).not.toHaveCount(0);

sau, dacă testul depinde de o cerere anume, waitForResponse pornit înainte de navigare.

Cum îi explici colegului: nu ca regulă impusă, ci cu un exemplu concret din suita voastră, unde înlocuirea a făcut testul mai rapid și mai stabil, și cu linkul din documentație. Dacă există cazuri în care chiar ai nevoie, de exemplu o captură vizuală după încărcarea tuturor imaginilor, le izolezi și le comentezi.

Ce urmărește intervievatorul: Combină tehnicul cu comunicarea. Se verifică dacă știi de ce networkidle e o falsă siguranță și dacă poți convinge un coleg fără să impui.

Eroarea, în practică:page.goto: Timeout 30000ms exceeded

38 Senior

Un test dă click pe „Adaugă în coș”, click-ul reușește, dar coșul rămâne gol, doar uneori și mai ales în CI. Pagina e randată pe server și apoi hidratată în React. Ce se întâmplă și cum rezolvi?

Răspuns scurt: Butonul e vizibil și acționabil în HTML-ul venit de la server înainte ca JavaScript-ul să atașeze handler-ul (hidratarea), deci click-ul ajunge pe un element fără efect. Te sincronizezi pe un semnal de pagină gata sau verifici efectul și reiei acțiunea controlat.

Pe pagini cu SSR (randare pe server, ca în Next.js sau Nuxt), browserul primește HTML complet: butonul există, e vizibil, stabil, activ. Playwright îl consideră acționabil și dă click imediat. Dar până când bundle-ul JS se încarcă și React face hidratarea (atașează handler-ele la DOM-ul existent), click-ul nu are niciun efect. Pe un runner CI mai lent, fereastra dintre afișare și hidratare e mai mare, de aici instabilitatea.

Diagnostic: în trace se vede click-ul reușit, nicio cerere spre /api/cart după el, iar în consolă eventual mesaje de hidratare. Reproduci local cu CPU încetinit (CDP Emulation.setCPUThrottlingRate în Chromium) sau rețea lentă pentru JS.

Soluții, în ordinea preferinței:

  • Repararea în aplicație: butonul e dezactivat până la hidratare (disabled în HTML-ul de server, activ după montare). E și o îmbunătățire pentru utilizatorii reali cu telefoane lente. Testul așteaptă singur, prin verificarea „enabled”.
  • Un semnal explicit de pagină gata: aplicația setează un atribut (data-hydrated="true" pe body) după montare, iar testul așteaptă await expect(page.locator('body')).toHaveAttribute('data-hydrated', 'true'), de exemplu într-o metodă open() din Page Object.
  • Verificarea efectului și reluarea, ca ultimă variantă:
JavaScript
await expect(async () => {
  await addButton.click();
  await expect(cartBadge).toHaveText('1', { timeout: 1_000 });
}).toPass({ timeout: 10_000 });

Atenție la ultima: dacă primul click a funcționat totuși, al doilea poate adăuga un produs în plus. De aceea e de evitat pentru acțiuni care nu sunt idempotente.

Ce urmărește intervievatorul: Întrebare de senior: se verifică dacă înțelegi limitele auto-waiting-ului și dacă știi să diagnostichezi, nu doar să adaugi pauze. Răspunsul bun propune și o schimbare în aplicație.

Aserțiuni

39 Junior

Care dintre cele două aserțiuni e corectă și de ce?

JavaScript
// A
expect(await page.getByTestId('status').textContent()).toBe('Comandă plasată');

// B
await expect(page.getByTestId('status')).toHaveText('Comandă plasată');

Răspuns scurt: B este corectă: e o aserțiune web-first care reîncearcă până când textul devine cel așteptat. A citește textul o singură dată, în momentul acela, deci pică dacă mesajul apare cu o clipă mai târziu.

Diferența ține de când se face verificarea.

În varianta A, textContent() așteaptă doar ca elementul să existe, apoi întoarce textul pe care îl are chiar atunci: de exemplu „Se procesează...”, dacă statusul se actualizează abia după răspunsul serverului. Apoi expect(...).toBe(...) compară două valori simple, o singură dată. Un mesaj care apare după 300 ms face testul să pice aleatoriu.

În varianta B, expect(locator).toHaveText(...) este o aserțiune web-first: Playwright reia citirea textului până când se potrivește sau până la expect.timeout (implicit 5 secunde). La eșec, mesajul conține valoarea așteptată, valoarea primită și istoricul încercărilor, deci e și mai ușor de depanat.

Atenție la două detalii din B:

  • await e obligatoriu în fața lui expect(locator), pentru că aserțiunea e asincronă. Fără el, testul poate trece înainte de verificare.
  • toHaveText cu string cere potrivirea întregului text (cu spațiile normalizate); pentru o parte din text folosești toContainText sau un regex.

Regula practică: pentru orice stare din pagină (text, vizibilitate, valoare, atribut, număr de elemente, URL, titlu) folosește matcherii pe locator sau page. expect(valoare) simplu rămâne pentru date deja calculate, de exemplu un răspuns de API sau un număr pe care l-ai calculat din texte.

Ce urmărește intervievatorul: Întrebare de bază care separă pe cine a scris teste stabile de cine a copiat tipare din Selenium. Greșeala tipică e varianta A „pentru că merge local”.

Eroarea, în practică:expect(locator).toHaveText(expected) failedexpect(received).toBeTruthy()

40 Junior

Cum verifici textul unui buton, conținutul unui câmp <input> și faptul că un mesaj conține un număr de comandă variabil?

Răspuns scurt: Pentru butonul folosești toHaveText, pentru <input> toHaveValue (valoarea nu este text în DOM), iar pentru mesajul variabil toHaveText cu regex sau toContainText pe partea fixă.

Matcherii au roluri clare:

  • toHaveText(text | regex | array): textul complet al elementului, cu spațiile normalizate.
  • toContainText(text): textul conține subșirul.
  • toHaveValue(valoare): valoarea curentă a unui input, textarea sau select. Ce tastează utilizatorul într-un câmp nu e un nod de text, deci toHaveText pe un input nu vede valoarea.
  • toHaveAttribute(nume, valoare), toHaveClass, toHaveCSS pentru atribute și stil.
JavaScript
await expect(page.getByRole('button', { name: /plătește/i }))
  .toHaveText('Plătește 149,99 lei');

const email = page.getByLabel('Email');
await email.fill('ana@test.ro');
await expect(email).toHaveValue('ana@test.ro');

await expect(page.getByRole('alert'))
  .toHaveText(/^Comanda #\d{6} a fost plasată\.$/);

await expect(page.getByLabel('Țara')).toHaveValue('RO');
await expect(page.getByRole('link', { name: 'Termeni' }))
  .toHaveAttribute('href', '/termeni');

Pentru numere variabile (ID-uri, date, ore), regexul este mai bun decât toContainText('Comanda #'): verifică și formatul, nu doar existența unui prefix. Dacă ai nevoie de numărul propriu-zis pentru pașii următori, îl extragi după ce aserțiunea a trecut:

JavaScript
const text = await page.getByRole('alert').textContent();
const nrComanda = text.match(/#(\d{6})/)[1];

Și toHaveText are opțiunea ignoreCase: true, iar useInnerText: true folosește innerText în loc de textContent, util când textul ascuns din element nu trebuie inclus.

Ce urmărește intervievatorul: Verifică dacă alegi matcherul potrivit. Greșeala tipică este toHaveText pe un input, care pică deși valoarea e corectă.

Eroarea, în practică:expect(locator).toHaveText(expected) failedexpect(locator).toContainText(expected) failed

41 Junior

Care e diferența dintre toBeVisible, toBeAttached, toBeHidden și not.toBeVisible? Cum verifici că un buton e dezactivat?

Răspuns scurt: toBeAttached cere doar ca elementul să existe în DOM, toBeVisible cere să existe și să fie vizibil, iar toBeHidden și not.toBeVisible trec dacă elementul lipsește sau e invizibil. Butonul dezactivat îl verifici cu toBeDisabled.

Pentru Playwright, un element e vizibil dacă are o casetă de dimensiune nenulă și nu are visibility: hidden. Un element cu opacity: 0 este considerat vizibil, iar unul scos din ecran prin scroll e tot vizibil (pentru „e în fereastră” există toBeInViewport).

  • toBeAttached(): elementul există în DOM, indiferent de stil. Util pentru elemente ascunse intenționat (un input de fișier).
  • toBeVisible(): există și e vizibil.
  • toBeHidden(): nu există sau nu e vizibil. Este echivalent cu not.toBeVisible().
  • not.toBeAttached(): elementul nu există deloc în DOM, mai strict decât toBeHidden.
JavaScript
await page.getByRole('button', { name: 'Trimite' }).click();
await expect(page.getByTestId('spinner')).toBeHidden();
await expect(page.getByRole('alert')).toBeVisible();

const plateste = page.getByRole('button', { name: 'Plătește' });
await expect(plateste).toBeDisabled();
await page.getByLabel('Accept termenii').check();
await expect(plateste).toBeEnabled();
await expect(page.getByLabel('Accept termenii')).toBeChecked();

Capcana cu negațiile: not.toBeVisible() trece imediat dacă elementul nu a apărut încă. Testul „după click, mesajul de eroare dispare” poate trece fals dacă verifici înainte ca mesajul să fi apărut. De aceea verifici întâi starea pozitivă (eroarea e vizibilă), apoi acțiunea, apoi negația.

toBeDisabled se uită la atributul disabled pe elementele de formular și la aria-disabled="true". Un buton doar „gri” prin CSS nu e dezactivat pentru Playwright, iar un test care trece de el apasă un buton pe care utilizatorul îl crede inactiv.

Ce urmărește intervievatorul: Se verifică precizia definițiilor. Mulți nu știu că negația trece imediat și scriu teste care nu pot pica.

Eroarea, în practică:element is not visibleexpect(locator).toBeVisible() failed

42 Junior

Care dintre aserțiunile de mai jos trec?

JavaScript
const a = { id: 1, tags: ['nou'] };
const b = { id: 1, tags: ['nou'] };

expect(a).toBe(b);
expect(a).toEqual(b);
expect([1, 2, 3]).toContain(2);
expect([{ id: 1 }]).toContain({ id: 1 });
expect({ id: 1, extra: undefined }).toEqual({ id: 1 });
expect({ id: 1, extra: undefined }).toStrictEqual({ id: 1 });

Răspuns scurt: Trec a doua, a treia și a cincea. toBe compară identitatea obiectelor, toContain folosește === pentru elemente, iar toStrictEqual ține cont de cheile cu undefined.

expect din Playwright are matcherii generici din stilul Jest, pentru valori deja calculate:

  • expect(a).toBe(b) pică: toBe folosește Object.is, adică aceeași referință. a și b sunt obiecte diferite cu același conținut. toBe e potrivit pentru primitive: numere, string-uri, boolean.
  • expect(a).toEqual(b) trece: comparație recursivă a conținutului.
  • expect([1, 2, 3]).toContain(2) trece: elementul primitiv e găsit cu ===.
  • expect([{ id: 1 }]).toContain({ id: 1 }) pică: obiectul literal e altă referință. Pentru obiecte în tablouri folosești toContainEqual({ id: 1 }).
  • toEqual ignoră proprietățile cu valoarea undefined, deci a cincea trece.
  • toStrictEqual le ia în considerare (și tipurile claselor, și golurile din tablouri), deci a șasea pică.

În testele de API, cele mai folosite sunt:

JavaScript
const body = await response.json();
expect(body).toMatchObject({ status: 'paid', items: [{ sku: 'TRC-ALB' }] });
expect(body.total).toBeCloseTo(149.99, 2);
expect(body.id).toEqual(expect.any(Number));
expect(body.tags).toEqual(expect.arrayContaining(['nou']));

toMatchObject verifică doar cheile pe care le dai, deci testul nu pică dacă API-ul adaugă un câmp nou, ceea ce de obicei e ce vrei.

Toți acești matcheri sunt sincroni și nu reîncearcă. Nu au nevoie de await și nu se folosesc pentru stări din pagină.

Ce urmărește intervievatorul: Întrebare clasică de „ce afișează”: verifică înțelegerea egalității prin referință vs prin valoare în JavaScript, sursă frecventă de teste care pică inexplicabil.

Eroarea, în practică:toBe(expected) // Object.is equalityreplace "toBe" with "toStrictEqual"

43 Junior

Coșul afișează trei linii cu subtotaluri de forma „1.299,99 lei” și un total. Scrie un test care verifică faptul că totalul este suma liniilor.

Răspuns scurt: Citești textele subtotalurilor după ce s-au încărcat, le transformi din formatul românesc în numere (scoți punctul de mii, înlocuiești virgula cu punct), le aduni și compari cu totalul folosind toBeCloseTo, nu toBe, din cauza zecimalelor în virgulă mobilă.

Pașii: sincronizare, extragere, conversie, calcul, comparare.

JavaScript
function pret(text) {
  // "1.299,99 lei" -> 1299.99
  const curat = text.replace(/[^\d,.-]/g, '').replace(/\./g, '').replace(',', '.');
  const n = Number(curat);
  if (Number.isNaN(n)) throw new Error(`Preț invalid: "${text}"`);
  return n;
}

test('totalul coșului este suma liniilor', async ({ page }) => {
  await page.goto('/cos');
  const subtotaluri = page.getByTestId('line-subtotal');
  await expect(subtotaluri).toHaveCount(3);

  const valori = (await subtotaluri.allTextContents()).map(pret);
  const suma = valori.reduce((s, v) => s + v, 0);
  const total = pret(await page.getByTestId('cart-total').textContent());

  expect(total).toBeCloseTo(suma, 2);
});

De ce fiecare detaliu:

  • toHaveCount(3) întâi: allTextContents() nu așteaptă, deci te asiguri că lista e completă.
  • Conversia: în formatul românesc punctul separă miile, iar virgula zecimalele. Number('1.299,99') ar da NaN, iar parseFloat ar da 1.299, o eroare tăcută.
  • Funcția aruncă eroare explicită pe text invalid, ca un NaN să nu facă testul să pice cu un mesaj confuz.
  • toBeCloseTo(suma, 2): 0.1 + 0.2 nu e exact 0.3 în virgulă mobilă. Al doilea argument e numărul de zecimale verificate.

Alternativ, poți lucra în bani (înmulțești cu 100 și rotunjești) ca să compari întregi. Testul acesta a prins în practică bug-uri reale de rotunjire și de reduceri aplicate o singură dată în loc de pe fiecare linie.

Ce urmărește intervievatorul: Exercițiu de live coding frecvent pe coș. Se urmărește conversia corectă a formatului local și compararea numerelor cu zecimale.

Eroarea, în practică:expect(received).toBeGreaterThan(expected)expect(received).not.toBeNaN()

44 Junior

Cum verifici că meniul afișează exact categoriile „Haine”, „Încălțăminte”, „Accesorii”, în această ordine?

Răspuns scurt: Cu await expect(locator).toHaveText(['Haine', 'Încălțăminte', 'Accesorii']) pe locatorul tuturor elementelor din meniu. Aserțiunea verifică numărul, ordinea și textul fiecăruia și reîncearcă până se potrivește.

toHaveText și toContainText acceptă un tablou. Atunci locatorul trebuie să se potrivească cu mai multe elemente, iar aserțiunea verifică:

  • că sunt exact atâtea elemente câte valori ai dat;
  • că fiecare element, în ordine, are textul corespunzător (complet la toHaveText, parțial la toContainText).
JavaScript
const categorii = page.getByRole('navigation', { name: 'Categorii' }).getByRole('link');

await expect(categorii).toHaveText(['Haine', 'Încălțăminte', 'Accesorii']);
await expect(categorii).toHaveCount(3);          // redundant aici, dar explicit
await expect(categorii.first()).toHaveAttribute('href', '/haine');

Avantaje față de varianta manuală cu allTextContents():

JavaScript
// funcționează, dar nu reîncearcă
expect(await categorii.allTextContents()).toEqual(['Haine', 'Încălțăminte', 'Accesorii']);
  • reîncercare automată până când meniul s-a încărcat complet;
  • mesaj de eroare clar, cu diferențele dintre listă și ce s-a găsit;
  • normalizarea spațiilor.

Pentru elemente fără ordine garantată, unde vrei doar să verifici prezența, compari mulțimile: expect((await categorii.allTextContents()).sort()).toEqual([...asteptat].sort()), după ce ai așteptat numărul corect cu toHaveCount.

Valorile din tablou pot fi și regex-uri, de exemplu pentru elemente care conțin și un contor: [/^Haine \(\d+\)$/, /^Încălțăminte/, /^Accesorii/].

Ce urmărește intervievatorul: Arată dacă știi matcherii de liste. Mulți scriu bucle cu nth(i) și verificări individuale, mai lente și fără reîncercare.

Eroarea, în practică:expect: strict mode violation (toHaveText)

45 Mid

Ce face expect.soft și când îl folosești? Ce riscuri are?

Răspuns scurt: O aserțiune soft înregistrează eșecul, dar lasă testul să continue; la final testul e marcat picat cu toate erorile. E utilă pentru mai multe verificări independente pe aceeași pagină, nu când pașii următori depind de rezultat.

O aserțiune normală oprește testul la primul eșec. Cu expect.soft, eșecul e notat și execuția merge mai departe:

JavaScript
test('pagina de produs afișează toate detaliile', async ({ page }) => {
  await page.goto('/produs/tricou-alb');
  await expect.soft(page.getByRole('heading', { level: 1 })).toHaveText('Tricou alb');
  await expect.soft(page.getByTestId('price')).toHaveText('49,99 lei');
  await expect.soft(page.getByTestId('stock')).toHaveText('În stoc');
  await expect.soft(page.getByRole('img', { name: 'Tricou alb' })).toBeVisible();

  // pas care depinde de pagină: aserțiune normală
  await expect(page.getByRole('button', { name: 'Adaugă în coș' })).toBeEnabled();
});

Dacă prețul și stocul sunt greșite, raportul arată ambele erori dintr-o singură rulare, în loc să descoperi a doua abia după ce o repari pe prima.

Când e potrivit: verificări independente pe aceeași stare (câmpurile unui formular, detaliile unei pagini, coloanele unui rând), mai ales în teste lente, unde fiecare rulare costă.

Riscuri:

  • dacă un pas critic pică soft, următoarele acțiuni rulează pe o stare greșită și produc erori în cascadă, mai greu de citit;
  • testul consumă tot timeout-ul pentru fiecare aserțiune soft eșuată (fiecare așteaptă până la 5 secunde).

Dacă vrei să te oprești totuși la un punct, verifici expect(test.info().errors).toHaveLength(0) înainte de pasul critic.

Ce urmărește intervievatorul: Se verifică dacă știi diferența dintre verificări independente și pași dependenți. Greșeala tipică este să faci toate aserțiunile soft.

46 Mid

Aserțiunile trebuie puse în Page Object sau în test? Argumentează.

Răspuns scurt: Practica dominantă: Page Object-ul expune acțiuni și locatori sau valori, iar aserțiunile rămân în test, ca să se vadă ce verifică testul. Excepții acceptate sunt verificările de stare a paginii („pagina s-a încărcat”) sau metodele explicite de tip expectX.

Argumentele pentru aserțiuni în test:

  • testul se citește ca o specificație: acțiuni, apoi ce trebuie să fie adevărat;
  • același Page Object servește și testelor pozitive, și celor negative. O metodă login() care verifică intern „sunt în cont” nu mai poate fi folosită în testul „parolă greșită”;
  • Page Object-ul rămâne un strat de interacțiune, cu o singură responsabilitate.
JavaScript
// Page Object
class CartPage {
  constructor(page) {
    this.page = page;
    this.total = page.getByTestId('cart-total');
    this.lines = page.getByTestId('cart-line');
  }
  async removeItem(name) {
    await this.lines.filter({ hasText: name })
      .getByRole('button', { name: 'Elimină' }).click();
  }
}

// test
await cart.removeItem('Tricou alb');
await expect(cart.lines).toHaveCount(1);
await expect(cart.total).toHaveText('89,99 lei');

Argumentele pentru câteva aserțiuni în Page Object:

  • verificări de sincronizare, care țin de pagină, nu de scenariu: open() care așteaptă ca titlul să fie vizibil;
  • verificări repetate identic în multe teste, expuse ca metode cu nume explicit, de exemplu expectProductInCart(name, qty).

Ce să eviți: metode care întorc true/false din isVisible() pentru a fi verificate apoi cu expect(...).toBe(true). Pierzi reîncercarea și mesajele bune. Expune locatorul și lasă testul să folosească expect(locator).

La interviu contează mai puțin tabăra aleasă și mai mult că o justifici și o aplici consecvent în toată suita.

Ce urmărește intervievatorul: Întrebare de design cu mai multe răspunsuri bune. Se urmărește argumentarea. Greșeala tipică e metoda care întoarce boolean și pierde reîncercarea.

Hooks, Page Object Model, fixtures și date de test

Exersează capitolul cu exerciții reale: Curs testare automată →
47 Junior

Ce afișează rularea fișierului de mai jos, cu un singur worker?

JavaScript
test.beforeAll(() => console.log('beforeAll'));
test.beforeEach(() => console.log('beforeEach'));
test.afterEach(() => console.log('afterEach'));
test.afterAll(() => console.log('afterAll'));

test('A', () => console.log('A'));

test.describe('grup', () => {
  test.beforeEach(() => console.log('beforeEach grup'));
  test('B', () => console.log('B'));
});

Răspuns scurt: Afișează: beforeAll, beforeEach, A, afterEach, beforeEach, beforeEach grup, B, afterEach, afterAll. Hook-urile exterioare rulează înaintea celor din describe, iar beforeAll/afterAll o dată pentru fișier, în acel worker.

Regulile:

  • beforeAll și afterAll declarate la nivelul fișierului rulează o dată per worker care execută teste din fișier, înaintea primului test și după ultimul.
  • beforeEach și afterEach rulează în jurul fiecărui test.
  • Pentru un test dintr-un describe, hook-urile beforeEach rulează de la exterior spre interior, iar afterEach de la interior spre exterior.

Deci ordinea este:

beforeAll
beforeEach
A
afterEach
beforeEach
beforeEach grup
B
afterEach
afterAll

Două nuanțe importante la interviu:

  • „Per worker”: dacă un test pică, Playwright închide workerul și pornește unul nou pentru testele rămase, iar acolo beforeAll rulează din nou. La fel cu fullyParallel: true, unde testele aceluiași fișier ajung în workeri diferiți. Deci nu te baza pe beforeAll ca „o singură dată în toată rularea”; pentru setup global există proiectele de setup (dependencies) sau globalSetup.
  • afterEach rulează și când testul pică, de aceea e locul potrivit pentru curățenie sau pentru atașamente de diagnostic.

Hook-urile primesc aceleași fixture-uri ca testele (async ({ page }) => ...), cu excepția lui beforeAll/afterAll, care au acces doar la fixture-urile cu scop de worker.

Ce urmărește intervievatorul: Puzzle de ordine frecvent. Se verifică dacă știi că beforeAll e per worker, nu per rulare, o sursă de surprize în suitele paralele.

48 Junior

Codul de mai jos dă eroare. De ce? Cum pregătești o stare comună pentru toate testele dintr-un fișier?

JavaScript
let page;
test.beforeAll(async ({ page: p }) => {
  page = p;
  await page.goto('/login');
});

Răspuns scurt: Fixture-ul page are scop de test, deci nu e disponibil în beforeAll, care are acces doar la fixture-uri de worker, ca browser. Starea comună o pregătești prin API sau prin sesiune salvată, iar fiecare test își deschide pagina lui.

Playwright refuză explicit să dea page (sau context) unui beforeAll, pentru că page se creează și se distruge pentru fiecare test, ca să păstreze izolarea. Eroarea spune că fixture-ul cu scop de test nu poate fi folosit într-un hook beforeAll.

Dacă ai forța asta creând manual o pagină comună:

JavaScript
let page;
test.beforeAll(async ({ browser }) => {
  page = await browser.newPage();
});

testele ar împărți aceeași pagină, aceleași cookie-uri și aceeași stare de UI. Un test care lasă un dialog deschis îl strică pe următorul, iar testele nu mai pot rula în paralel sau individual. Există situații rare în care se face intenționat, împreună cu test.describe.configure({ mode: 'serial' }), dar e excepția.

Alternativele corecte:

  • Date comune: le creezi prin API în beforeAll, cu fixture-ul de worker playwright.request sau request.newContext(), și le folosești în fiecare test.
  • Autentificare comună: un proiect de setup care salvează storageState, iar testele pornesc cu sesiunea gata.
  • Navigare comună: în beforeEach, cu page propriu fiecărui test. Un goto costă puțin.
JavaScript
test.beforeEach(async ({ page }) => {
  await page.goto('/produse');
});

Regula: ce e scump și sigur de partajat (date, token) se pregătește o dată; ce ține de starea browserului se recreează pentru fiecare test.

Ce urmărește intervievatorul: Se verifică înțelegerea scopurilor de fixture și a izolării. Candidații care vin din Selenium încearcă des să refolosească un browser pentru toate testele.

Eroarea, în practică:"page" fixtures are not supported in "beforeAll"

49 Junior

Scrie un Page Object ProductPage pentru pagina unui produs: deschidere după slug, alegerea mărimii, adăugarea în coș și citirea prețului ca număr.

Răspuns scurt: O clasă care primește page în constructor, își definește locatorii ca proprietăți și expune metode asincrone pentru acțiuni (open, selectSize, addToCart) și pentru valori (getPrice), fără aserțiuni de scenariu.

JavaScript
// pages/ProductPage.js
export class ProductPage {
  constructor(page) {
    this.page = page;
    this.title = page.getByRole('heading', { level: 1 });
    this.price = page.getByTestId('price');
    this.size = page.getByLabel('Mărime');
    this.addButton = page.getByRole('button', { name: 'Adaugă în coș' });
    this.cartBadge = page.getByTestId('cart-badge');
  }

  async open(slug) {
    await this.page.goto(`/produs/${slug}`);
    await this.title.waitFor();
  }

  async selectSize(size) {
    await this.size.selectOption(size);
  }

  async addToCart() {
    await this.addButton.click();
  }

  async getPrice() {
    const text = await this.price.textContent();
    return Number(text.replace(/[^\d,]/g, '').replace(',', '.'));
  }
}

Folosire:

JavaScript
import { ProductPage } from '../pages/ProductPage';

test('adaugă tricoul M în coș', async ({ page }) => {
  const product = new ProductPage(page);
  await product.open('tricou-alb');
  await product.selectSize('M');
  await product.addToCart();
  await expect(product.cartBadge).toHaveText('1');
  expect(await product.getPrice()).toBeCloseTo(49.99, 2);
});

Decizii de design:

  • Locatorii se definesc în constructor; fiind lazy, nu caută nimic până la folosire, deci constructorul rămâne sincron. Un constructor nu poate fi async, de aceea navigarea stă în open(), nu în constructor.
  • Metodele au nume din limbajul domeniului (addToCart), nu din UI (clickButton3).
  • Locatorii sunt expuși, ca testul să poată folosi aserțiunile web-first pe ei.
  • getPrice() face conversia o singură dată, într-un singur loc.

Ce urmărește intervievatorul: Exercițiu standard de live coding. Se urmărește separarea responsabilităților și dacă știi de ce navigarea nu stă în constructor.

Eroarea, în practică:Cannot read properties of undefined (reading 'goto')

50 Junior

Ce înseamnă că o metodă de Page Object „întoarce alt Page Object” și când e util?

Răspuns scurt: O metodă care duce utilizatorul pe altă pagină întoarce instanța Page Object-ului acelei pagini, de exemplu login() întoarce AccountPage. Testul devine un flux citibil și nu poți apela din greșeală metode ale paginii pe care nu mai ești.

Ideea vine din tiparul clasic Page Object din Selenium: fiecare acțiune care schimbă pagina modelează tranziția în cod.

JavaScript
export class LoginPage {
  constructor(page) {
    this.page = page;
    this.email = page.getByLabel('Email');
    this.password = page.getByLabel('Parolă');
    this.submit = page.getByRole('button', { name: 'Autentificare' });
  }
  async loginAs(email, password) {
    await this.email.fill(email);
    await this.password.fill(password);
    await this.submit.click();
    await this.page.waitForURL('**/cont');
    return new AccountPage(this.page);
  }
}

export class AccountPage {
  constructor(page) {
    this.page = page;
    this.ordersLink = page.getByRole('link', { name: 'Comenzile mele' });
  }
  async openOrders() {
    await this.ordersLink.click();
    return new OrdersPage(this.page);
  }
}

Testul:

JavaScript
const account = await new LoginPage(page).loginAs('ana@test.ro', parola);
const orders = await account.openOrders();
await expect(orders.rows).toHaveCount(2);

Avantaje: fluxul se citește ca o poveste, IDE-ul sugerează doar metodele valabile pe pagina curentă, iar sincronizarea pe navigare (waitForURL) e într-un singur loc.

Limite: dacă aceeași acțiune poate duce în locuri diferite (login reușit sau eșuat), ai nevoie de metode separate (loginAs și loginExpectingError) sau de o metodă care nu întoarce nimic, urmată de aserțiuni în test. Nu forța tiparul acolo unde tranziția nu e determinată.

În Playwright, multe echipe preferă alternativ fixture-uri care oferă toate Page Object-urile gata create; cele două abordări se pot combina.

Ce urmărește intervievatorul: Verifică dacă știi tiparele de design pentru fluxuri. Greșeala tipică este o metodă care întoarce mereu aceeași pagină, indiferent unde ajunge utilizatorul.

51 Junior

Ce e o fixture în Playwright și prin ce diferă de un beforeEach? Scrie o fixture care oferă testelor un CartPage gata creat.

Răspuns scurt: O fixture este o resursă declarată cu test.extend, creată doar pentru testele care o cer și distrusă după, cu setup și teardown în aceeași funcție. Spre deosebire de beforeEach, e reutilizabilă între fișiere, compozabilă și leneșă.

O fixture se definește extinzând obiectul test:

JavaScript
// fixtures.js
import { test as base, expect } from '@playwright/test';
import { CartPage } from './pages/CartPage';
import { ProductPage } from './pages/ProductPage';

export const test = base.extend({
  productPage: async ({ page }, use) => {
    await use(new ProductPage(page));
  },
  cartPage: async ({ page }, use) => {
    const cart = new CartPage(page);
    await cart.open();
    await use(cart);
  },
});
export { expect };

Testele importă test din fixtures.js:

JavaScript
import { test, expect } from '../fixtures';

test('coșul gol afișează mesajul', async ({ cartPage }) => {
  await expect(cartPage.emptyMessage).toBeVisible();
});

Diferențele față de beforeEach:

  • Leneșă: rulează doar dacă testul o cere în parametri. Un beforeEach rulează pentru toate testele din fișier sau din grup.
  • Reutilizabilă: o definești o dată și o folosești în orice fișier, fără variabile let la nivel de modul.
  • Setup și teardown împreună: codul de dinainte de use() e setup, cel de după e teardown, cu acces la aceleași variabile.
  • Compozabilă: o fixture poate depinde de alte fixture-uri (page, request, una proprie).
  • Scop configurabil: per test sau per worker.

page, context, browser și request sunt ele însele fixture-uri încorporate, definite exact în acest fel.

Ce urmărește intervievatorul: Este întrebarea standard despre fixture-uri. Se urmărește dacă înțelegi rolul lui use() și avantajele concrete față de hook-uri.

Eroarea, în practică:ReferenceError: page is not definedTest timeout ... while setting up fixture

52 Junior

Scrie o fixture care creează un produs prin API înainte de test și îl șterge după, chiar dacă testul pică.

Răspuns scurt: În fixture creezi produsul cu request.post, dai obiectul testului prin await use(produs), iar după use faci request.delete. Codul de după use() rulează și când testul pică, deci curățenia e garantată.

JavaScript
import { test as base, expect } from '@playwright/test';

export const test = base.extend({
  product: async ({ request }, use, testInfo) => {
    // setup
    const res = await request.post('/api/admin/products', {
      data: {
        name: `Produs test ${testInfo.workerIndex}-${Date.now()}`,
        price: 99.9,
        stock: 5,
      },
      headers: { Authorization: `Bearer ${process.env.ADMIN_TOKEN}` },
    });
    expect(res.ok()).toBeTruthy();
    const product = await res.json();

    // testul rulează aici
    await use(product);

    // teardown, rulează și dacă testul a picat
    await request.delete(`/api/admin/products/${product.id}`, {
      headers: { Authorization: `Bearer ${process.env.ADMIN_TOKEN}` },
    });
  },
});

test('produsul nou apare în căutare', async ({ page, product }) => {
  await page.goto(`/cauta?q=${encodeURIComponent(product.name)}`);
  await expect(page.getByTestId('product-card')).toHaveText([new RegExp(product.name)]);
});

Detalii care contează:

  • Nume unic (worker și timestamp): testele rulează în paralel, iar două teste care creează „Produs test” s-ar încurca la căutare.
  • Verificarea res.ok() în setup: dacă API-ul pică, eroarea apare clar în fixture, nu ca un element negăsit în UI.
  • Teardown-ul de după use() rulează și la eșec. Dacă și testul și teardown-ul pică, ambele erori apar în raport.
  • Setup-ul prin API e mult mai rapid decât crearea produsului prin interfața de admin și nu depinde de acel UI.

Tokenul vine din variabile de mediu, nu din cod.

Ce urmărește intervievatorul: Verifică stăpânirea ciclului de viață al unei fixture. Greșeala tipică este curățenia pusă la finalul testului, care nu rulează când testul pică.

53 Junior

Cum rulezi același test de validare pentru mai multe valori ale câmpului „Cantitate” (0, 1, 10, 11, -1, „abc”)?

Răspuns scurt: Definești datele ca tablou de cazuri, cu valoare și rezultat așteptat, și generezi câte un test pentru fiecare într-o buclă, cu titlu unic. Fiecare caz apare separat în raport și poate fi rulat singur.

Playwright nu are un test.each ca Jest, dar testele se pot genera dintr-o buclă, pentru că declararea lor e cod JavaScript obișnuit:

JavaScript
const cazuri = [
  { valoare: '0',   valid: false, mesaj: 'Cantitatea minimă este 1' },
  { valoare: '1',   valid: true },
  { valoare: '10',  valid: true },
  { valoare: '11',  valid: false, mesaj: 'Cantitatea maximă este 10' },
  { valoare: '-1',  valid: false, mesaj: 'Cantitatea minimă este 1' },
  { valoare: 'abc', valid: false, mesaj: 'Introdu un număr' },
];

test.describe('validarea cantității', () => {
  for (const { valoare, valid, mesaj } of cazuri) {
    test(`cantitatea "${valoare}" este ${valid ? 'acceptată' : 'respinsă'}`, async ({ page }) => {
      await page.goto('/produs/tricou-alb');
      await page.getByLabel('Cantitate').fill(valoare);
      await page.getByRole('button', { name: 'Adaugă în coș' }).click();

      if (valid) {
        await expect(page.getByTestId('cart-badge')).toHaveText(valoare);
      } else {
        await expect(page.getByRole('alert')).toHaveText(mesaj);
        await expect(page.getByTestId('cart-badge')).toBeHidden();
      }
    });
  }
});

Observații:

  • Valorile alese urmează analiza valorilor limită: imediat sub minim, minimul, maximul, imediat peste maxim, plus valori invalide ca tip.
  • Titlurile trebuie să fie unice, altfel Playwright raportează eroare de test duplicat. Includerea valorii în titlu ajută și la citirea raportului.
  • Un if simplu pe tipul cazului e acceptabil; dacă ramurile cresc, sparge în două liste (valide și invalide) cu teste separate.
  • Pentru <input type="number">, browserul poate refuza textul „abc”; atunci testul verifică că valoarea rămâne goală.

Ce urmărește intervievatorul: Verifică testarea bazată pe date și aplicarea tehnicilor de design de teste în automatizare. Mulți copiază același test de șase ori.

Eroarea, în practică:duplicate test title, first declared in

54 Junior

Ce este un „builder” sau o „fabrică” de date de test și de ce e mai bun decât obiecte copiate în fiecare test?

Răspuns scurt: O funcție care creează un obiect valid cu valori implicite rezonabile și unice, în care testul suprascrie doar câmpurile relevante pentru el. Testele devin scurte, intenția e clară, iar o schimbare de model se face într-un singur loc.

Fără builder, fiecare test conține un obiect complet:

JavaScript
const user = { firstName: 'Ana', lastName: 'Pop', email: 'ana@test.ro',
  phone: '0712345678', country: 'RO', city: 'Cluj', zip: '400000', newsletter: false };

Probleme: nu se vede ce câmp contează pentru test, același email duce la conflicte la rulare în paralel, iar când apare un câmp obligatoriu nou, modifici zeci de fișiere.

Cu o fabrică:

JavaScript
// data/factories.js
let seq = 0;
export function buildUser(overrides = {}) {
  seq += 1;
  const id = `${Date.now()}-${process.pid}-${seq}`;
  return {
    firstName: 'Ana',
    lastName: 'Test',
    email: `ana.${id}@test.ro`,
    phone: '0712345678',
    country: 'RO',
    city: 'Cluj-Napoca',
    zip: '400000',
    newsletter: false,
    ...overrides,
  };
}

În teste se vede doar ce e relevant:

JavaScript
const user = buildUser({ phone: '07123' });      // testul despre telefon invalid
const vip = buildUser({ newsletter: true });

Avantaje:

  • Intenție vizibilă: suprascrierea arată exact ce testează cazul.
  • Unicitate: emailul include timestamp, PID și contor, deci testele paralele nu se ciocnesc.
  • Un singur loc de întreținere când se schimbă modelul.
  • Combinabil cu fixture-uri: fixture-ul ia obiectul din builder și îl creează prin API.

Pentru date realiste în volum mare există biblioteci precum @faker-js/faker, dar cu valori aleatoare trebuie să loghezi datele folosite, altfel un eșec nu se mai poate reproduce.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat cu suite mari. Greșeala tipică sunt datele aleatoare nelogate, care fac eșecurile imposibil de reprodus.

55 Mid

Ce e greșit în acest Page Object?

JavaScript
class CheckoutPage {
  constructor(page) {
    this.page = page;
    this.page.goto('/checkout');
  }
  async fillAddress(a) {
    await this.page.fill('#address', a.street);
    await this.page.fill('#city', a.city);
    await this.page.waitForTimeout(1000);
    expect(await this.page.isVisible('.ok')).toBe(true);
  }
  async clickButton2() {
    await this.page.locator('.btn').nth(1).click();
  }
}

Răspuns scurt: Navigarea din constructor nu e așteptată, sunt folosite API vechi pe selectori fragili, are o pauză fixă, o aserțiune fără reîncercare ascunsă într-o metodă de acțiune, iar clickButton2 descrie UI-ul, nu intenția.

Problemele, pe rând:

  • goto în constructor fără await: constructorul nu poate fi asincron, deci promisiunea rămâne neașteptată. Testul poate începe să completeze câmpuri înainte de navigare, iar o eroare de navigare devine „unhandled rejection”. Navigarea merge într-o metodă async open().
  • page.fill('#address'): API-ul vechi pe selectori string; în plus, ID-urile pot fi generate. Locatorii se definesc o dată, ca proprietăți, cu getByLabel.
  • waitForTimeout(1000): pauză fixă, lentă și instabilă.
  • Aserțiune în metoda de acțiune: fillAddress nu mai poate fi folosită în teste negative, iar isVisible() nu așteaptă, deci aserțiunea e instabilă.
  • clickButton2 cu .btn și nth(1): numele nu spune ce face, iar indexul se strică dacă se adaugă un buton.

Varianta corectată:

JavaScript
export class CheckoutPage {
  constructor(page) {
    this.page = page;
    this.street = page.getByLabel('Stradă');
    this.city = page.getByLabel('Oraș');
    this.continueButton = page.getByRole('button', { name: 'Continuă spre plată' });
    this.confirmation = page.getByTestId('address-ok');
  }
  async open() {
    await this.page.goto('/checkout');
  }
  async fillAddress({ street, city }) {
    await this.street.fill(street);
    await this.city.fill(city);
  }
  async continueToPayment() {
    await this.continueButton.click();
  }
}

În test: await expect(checkout.confirmation).toBeVisible(). Fiecare problemă de mai sus apare des în suitele reale, iar la code review merită semnalate cu explicația, nu doar cu „schimbă asta”.

Ce urmărește intervievatorul: Întrebare de code review. Se urmărește câte probleme găsești și dacă explici consecințele, mai ales promisiunea neașteptată din constructor.

56 Mid

Antetul (căutare, coș, meniul de cont) apare pe toate paginile. Îl modelezi printr-un BasePage moștenit de toate Page Object-urile sau ca o componentă separată? De ce?

Răspuns scurt: Preferabil ca o componentă separată, compusă în paginile care o au. Moștenirea dintr-un BasePage tinde să crească într-o clasă uriașă cu tot ce e comun și leagă toate paginile de o structură care nu se potrivește tuturor.

Compoziția modelează mai fidel interfața: o pagină *are* un antet, un coș lateral, un dialog de cookie, nu *este* un antet.

JavaScript
// components/Header.js
export class Header {
  constructor(page) {
    const root = page.getByRole('banner');
    this.search = root.getByRole('searchbox', { name: 'Caută' });
    this.cartBadge = root.getByTestId('cart-badge');
    this.accountMenu = root.getByRole('button', { name: 'Contul meu' });
  }
  async searchFor(text) {
    await this.search.fill(text);
    await this.search.press('Enter');
  }
}

// pages/ProductPage.js
export class ProductPage {
  constructor(page) {
    this.page = page;
    this.header = new Header(page);
    this.addButton = page.getByRole('button', { name: 'Adaugă în coș' });
  }
}

Testul: await product.header.searchFor('tricou').

Avantajele compoziției:

  • Locatori ancorați în rădăcina componentei (banner), deci nu se amestecă cu elementele paginii.
  • Reutilizare selectivă: pagina de checkout fără antet complet nu moștenește metode care nu există pe ea.
  • Componente repetate (cardul de produs) devin clase instanțiate pe un locator: new ProductCard(page.getByTestId('product-card').nth(0)).

Problemele unui BasePage care crește: ajunge să conțină antetul, subsolul, bannerul de cookie, notificările, funcții utilitare de date, și orice schimbare atinge toate paginile.

Un BasePage mic rămâne acceptabil pentru lucruri cu adevărat comune tuturor paginilor (referința page, o metodă generică de așteptare a încărcării). La interviu, menționezi principiul „composition over inheritance” cu un exemplu concret, nu doar numele lui.

Ce urmărește intervievatorul: Se verifică gândirea de design în automatizare. Candidații de nivel mid ar trebui să recunoască problema clasei de bază care crește continuu.

57 Mid

Ce sunt fixture-urile cu scop de worker și fixture-urile automate (auto: true)? Dă câte un caz de folosire.

Răspuns scurt: O fixture scope: 'worker' se creează o dată per worker și e partajată de testele lui, potrivită pentru resurse scumpe (un cont de test, o conexiune). Una cu auto: true rulează pentru fiecare test chiar dacă nu e cerută, potrivită pentru logare sau verificări globale.

Ambele se declară cu un tablou [funcție, opțiuni] în test.extend.

Scop de worker: un cont de test unic per worker, creat o dată, refolosit de toate testele din acel worker, dar diferit de al celorlalți workeri, ca să nu se încurce în paralel.

JavaScript
export const test = base.extend({
  account: [async ({ playwright }, use, workerInfo) => {
    const api = await playwright.request.newContext({ baseURL: process.env.API_URL });
    const email = `worker${workerInfo.workerIndex}-${Date.now()}@test.ro`;
    const res = await api.post('/api/users', { data: { email, password: 'Parola!123' } });
    const user = await res.json();
    await use({ ...user, password: 'Parola!123' });
    await api.delete(`/api/users/${user.id}`);
    await api.dispose();
  }, { scope: 'worker' }],
});

Fixture-urile de worker nu pot depinde de fixture-uri cu scop de test (page), de aceea aici se folosește playwright.request, nu request.

Automată: colectează erorile din consola browserului pentru fiecare test și pică testul dacă apar.

JavaScript
export const test = base.extend({
  consoleErrors: [async ({ page }, use) => {
    const errors = [];
    page.on('pageerror', e => errors.push(e.message));
    await use(errors);
    expect(errors, 'erori JavaScript în pagină').toEqual([]);
  }, { auto: true }],
});

Atenție la fixture-urile automate: rulează pentru toate testele, deci un cost mic se înmulțește. Iar starea partajată de worker trebuie tratată ca imuabilă sau resetată, altfel testele din același worker se influențează.

Ce urmărește intervievatorul: Întrebare de mid care verifică înțelegerea scopurilor și a izolării. Greșeala tipică este o fixture de worker care depinde de page.

Eroarea, în practică:"page" fixtures are not supported in "beforeAll"

58 Mid

Când ai folosi test.describe.serial (sau mode: 'serial') și ce dezavantaje are?

Răspuns scurt: Pentru un flux unde pașii chiar depind unul de altul și nu se pot pregăti independent, de exemplu un wizard lung fără setup prin API. Dezavantaje: dacă un test pică, restul sunt sărite, nu se paralelizează, iar la retry se reia tot grupul.

În modul serial, testele unui describe rulează în ordine, în același worker, și sunt tratate ca un bloc:

JavaScript
test.describe.configure({ mode: 'serial' });

let orderId;
test('clientul plasează comanda', async ({ page }) => {
  // ...
  orderId = await page.getByTestId('order-id').textContent();
});

test('adminul aprobă comanda', async ({ page }) => {
  // folosește orderId
});

Comportamentul: dacă primul test pică, cele următoare sunt marcate „skipped”. Cu retry, se reia întreg grupul, de la început. test.describe.serial(...) e forma mai veche, echivalentă.

Când e justificat:

  • un flux care trece prin stări greu de creat altfel, iar fiecare stare e scumpă;
  • un mediu de test unde nu ai API sau acces la baza de date pentru setup;
  • teste exploratorii sau de demo, unde ordinea e intenția.

De ce documentația îl descurajează:

  • testele nu mai sunt independente, deci nu poți rula unul singur;
  • paralelizarea se pierde pentru acel grup;
  • raportul arată mai multe teste, dar de fapt e un singur scenariu.

Alternativa mai bună în majoritatea cazurilor: un singur test cu test.step pentru fiecare etapă (raportul arată tot pașii separat), sau o fixture care aduce comanda direct în starea „plasată” prin API, astfel încât testul adminului să fie independent.

Există și mode: 'parallel', opusul: testele aceluiași fișier rulează în workeri diferiți, util pentru fișiere mari cu teste independente.

Ce urmărește intervievatorul: Verifică dacă știi să tratezi excepția fără să o faci regulă. Greșeala tipică este folosirea modului serial ca să „repari” teste care își strică starea între ele.

59 Senior

Un test E2E de 70 de pași acoperă tot traseul: înregistrare, căutare, coș, cupon, checkout, anulare. Pică des și e greu de depanat. Cum îl restructurezi?

Răspuns scurt: Îl spargi în teste scurte, fiecare cu un singur comportament și cu precondițiile aduse prin API sau prin sesiune salvată. Păstrezi eventual un singur flux complet, scurt, ca smoke test pentru drumul fericit.

Un test lung are câteva probleme structurale: orice eșec timpuriu ascunde verificările de după, durata mare îl face sensibil la orice instabilitate, iar mesajul de eroare de la pasul 54 nu spune nimic fără contextul celor 53 dinainte.

Pașii de restructurare:

1. Identifici comportamentele pe care testul le verifică de fapt: înregistrare validă, căutare, adăugare în coș, aplicarea cuponului, calculul totalului, plasarea comenzii, anularea.

2. Pentru fiecare, decizi precondiția și cum o creezi fără UI:

  • „utilizator logat” → storageState dintr-un proiect de setup;
  • „coș cu două produse” → cereri API în fixture;
  • „comandă plasată” → API, apoi testul de anulare pornește direct de pe pagina comenzii.

3. Scrii teste scurte:

JavaScript
test('cuponul REDUCERE10 scade 10% din subtotal', async ({ cartWithTwoItems, cartPage }) => {
  await cartPage.applyCoupon('REDUCERE10');
  await expect(cartPage.discount).toHaveText('-13,90 lei');
});

4. Păstrezi un flux complet (smoke), dar scurt, cu test.step pentru etape, ca să verifici că piesele merg împreună.

Rezultatul: eșecurile indică direct comportamentul stricat, testele rulează în paralel, iar suita totală devine de obicei mai rapidă, deși are mai multe teste. Un efect secundar util: ai nevoie de endpoint-uri sau scripturi de setup, iar cererea lor către developeri e o investiție care servește toată echipa.

Ce urmărește intervievatorul: Întrebare de senior despre design de suită. Se urmărește dacă știi să muți setup-ul din UI și să păstrezi totuși o verificare de integrare a fluxului.

60 Senior

Suita are mai multe fișiere cu fixture-uri create de echipe diferite (pagini, date, autentificare, API). Cum le organizezi ca să rămână ușor de folosit?

Răspuns scurt: Le grupezi pe domenii în fișiere separate, le combini într-un singur test exportat cu mergeTests și separi clar ce e per test și ce e per worker. Testele importă dintr-un singur loc, iar dependențele dintre fixture-uri rămân explicite.

Fără regulă, fiecare fișier de teste ajunge să importe alt test extins, iar fixture-urile se dublează.

O structură care scalează:

fixtures/
  pages.js      // productPage, cartPage, checkoutPage
  data.js       // product, cartWithTwoItems (prin API)
  auth.js       // account (scop worker), adminContext
  index.js      // combină tot
JavaScript
// fixtures/index.js
import { mergeTests, mergeExpects } from '@playwright/test';
import { test as pages } from './pages';
import { test as data } from './data';
import { test as auth } from './auth';
import { expect as customExpect } from './matchers';

export const test = mergeTests(pages, data, auth);
export const expect = mergeExpects(customExpect);

mergeTests și mergeExpects există din versiunea 1.39. Fiecare echipă își întreține modulul, iar testele scriu doar import { test, expect } from '../fixtures'.

Principii de design:

  • Granularitate: fixture-uri mici, care fac un lucru, compuse prin dependențe (cartWithTwoItems depinde de account și de request).
  • Nume din domeniu: paidOrder, nu setup3.
  • Scop explicit: per worker doar resursele scumpe și sigur de partajat; tot restul per test.
  • Opțiuni configurabile: fixture-uri option: true (de exemplu locale sau tipul de utilizator) setate cu test.use sau pe proiecte.
  • Teardown obligatoriu pentru tot ce creează date.
  • Documentare minimă: un fișier sau comentarii JSDoc care spun ce oferă fiecare fixture, pentru că IDE-ul le sugerează doar după nume.

Ca semnal de alarmă: o fixture care primește zece parametri sau una pe care o cer toate testele fără motiv.

Ce urmărește intervievatorul: Întrebare de arhitectură pentru suite mari. Se verifică dacă știi mergeTests și dacă gândești în module, nu într-un fișier unic de setup.

61 Senior

Ai moștenit o suită cu 40 de Page Objects, un BasePage de 800 de linii și metode duplicate. Testele pică la fiecare schimbare de UI. Cum procedezi?

Răspuns scurt: Nu rescrii tot dintr-o dată. Măsori unde se pierde timpul, stabilești convenții noi, refactorizezi incremental începând cu paginile care pică cel mai des, ții suita verde pe tot parcursul și împarți munca cu echipa prin code review.

Un răspuns structurat pe situație, acțiuni și rezultat:

Înțelegerea situației. Aduni date: care teste pică cel mai des și de ce (locatori, sincronizare, date), ce metode se repetă, ce părți din BasePage sunt folosite efectiv. Un istoric de câteva săptămâni din CI arată unde e durerea reală.

Convenții înainte de cod. Stabilești cu echipa, în scris, câteva reguli: locatori pe rol și test id, componente pentru părțile comune, fără aserțiuni în metodele de acțiune, fără pauze fixe. Fără ele, codul nou va reproduce problemele.

Refactorizare incrementală.

  • Extragi componentele comune (antet, coș lateral, dialoguri) din BasePage, una câte una.
  • Refaci întâi Page Object-urile paginilor care produc cele mai multe eșecuri.
  • Elimini metodele moarte (căutare în cod după utilizări).
  • Fiecare pas e un PR mic, cu suita verde înainte și după.

Prevenție. Reguli de lint (pluginul ESLint pentru Playwright), un șablon de Page Object, revizie pe PR-urile de teste. Ceri developerilor data-testid pe elementele fără semantică.

Comunicare. Explici managerului costul actual (timp pierdut pe reparații, încredere scăzută în CI) și planul în etape, fără să promiți o dată la care „totul e gata”.

Rezultatul urmărit: mai puține eșecuri cauzate de teste după schimbări de UI și timp mai mic de reparare, verificate pe aceleași date din CI.

Ce urmărește intervievatorul: Întrebare de situație pentru senior. Se urmărește planul incremental și bazat pe date. Răspunsul slab este „rescriu framework-ul de la zero”.

Testare API, mock-uri de rețea și autentificare

62 Junior

Care este diferența dintre fixture-ul request, page.request și un context creat cu request.newContext() în Playwright?

Răspuns scurt: Toate sunt APIRequestContext, dar diferă prin cookie-uri: request e izolat per test și nu împarte sesiunea cu browserul, page.request folosește cookie-urile contextului de browser, iar request.newContext() creează un context separat, controlat complet de tine.

Playwright poate trimite cereri HTTP direct, fără browser, prin APIRequestContext. Ai trei moduri de a-l obține:

  • Fixture-ul request: creat pentru fiecare test, preia baseURL, extraHTTPHeaders, httpCredentials și ignoreHTTPSErrors din config. Are propriile cookie-uri, separate de browser. Bun pentru teste de API pure și pentru pregătirea datelor.
  • page.request (sau context.request): împarte cookie-urile cu contextul de browser. Dacă te-ai logat în pagină, cererile sunt autentificate; dacă cererea API setează un cookie, pagina îl vede.
  • request.newContext(opțiuni) (importat din @playwright/test) sau playwright.request.newContext() în fixture-uri de worker: un context pe care îl creezi și îl închizi tu (dispose()), cu headere și storageState proprii. Util în globalSetup, în fixture-uri de worker sau pentru un al doilea utilizator.
JavaScript
test('coșul creat prin API apare în UI', async ({ page }) => {
  await page.goto('/login');
  // ... login în UI
  await page.request.post('/api/cart/items', { data: { sku: 'TRC-ALB', qty: 2 } });
  await page.goto('/cos');
  await expect(page.getByTestId('cart-line')).toHaveCount(1);
});

Cu fixture-ul request în loc de page.request, cererea ar fi plecat neautentificată (sau pentru alt utilizator), iar coșul din UI ar fi rămas gol.

Toate oferă get, post, put, patch, delete, fetch, iar răspunsul are status(), ok(), json(), text(), headers().

Ce urmărește intervievatorul: Se verifică dacă știi cum se leagă sesiunea între API și browser. Greșeala tipică este folosirea lui request și surpriza că cererea nu e autentificată.

63 Junior

Scrie teste API cu Playwright pentru POST /api/login: parolă greșită, câmp lipsă și login reușit.

Răspuns scurt: Trimiți cererile cu fixture-ul request, verifici statusul (401, 400, 200), structura corpului și, la eșec, că nu vine niciun token. La succes, verifici că tokenul există și că funcționează pe un endpoint protejat.

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

test.describe('POST /api/login', () => {
  test('parola greșită întoarce 401 fără token', async ({ request }) => {
    const res = await request.post('/api/login', {
      data: { email: 'ana@test.ro', password: 'gresit' },
    });
    expect(res.status()).toBe(401);
    const body = await res.json();
    expect(body).not.toHaveProperty('token');
    expect(body.error).toBe('Email sau parolă incorecte');
  });

  test('emailul lipsă întoarce 400', async ({ request }) => {
    const res = await request.post('/api/login', { data: { password: 'x' } });
    expect(res.status()).toBe(400);
  });

  test('login valid întoarce un token folosibil', async ({ request }) => {
    const res = await request.post('/api/login', {
      data: { email: 'ana@test.ro', password: process.env.TEST_PASSWORD },
    });
    expect(res.status()).toBe(200);
    const { token } = await res.json();
    expect(token).toEqual(expect.any(String));

    const me = await request.get('/api/me', {
      headers: { Authorization: `Bearer ${token}` },
    });
    expect(me.ok()).toBeTruthy();
    expect((await me.json()).email).toBe('ana@test.ro');
  });
});

Ce merită subliniat:

  • La eșec verifici și ce nu trebuie să existe (tokenul), nu doar statusul.
  • Mesajul de eroare nu trebuie să spună dacă emailul există („utilizator inexistent” vs „parolă greșită”), altfel permite enumerarea conturilor.
  • Tokenul se validează folosindu-l, nu doar prin prezență.
  • Cererile request nu aruncă eroare la status 4xx sau 5xx (decât cu opțiunea failOnStatusCode: true), deci verificarea statusului e obligatorie.

Ce urmărește intervievatorul: Exercițiu de live coding pentru API. Se urmărește testarea negativă completă și faptul că nu te oprești la status.

Eroarea, în practică:expect(response).toBeOK() failed

64 Junior

Cum testezi ce afișează pagina de catalog când API-ul întoarce o listă goală, fără să ștergi produsele din baza de date?

Răspuns scurt: Interceptezi cererea spre /api/products cu page.route și răspunzi cu route.fulfill({ json: [] }), înregistrând ruta înainte de goto. Apoi verifici mesajul de stare goală.

page.route(url, handler) interceptează cererile din pagină care se potrivesc cu un glob, regex sau predicat. Handler-ul decide ce se întâmplă cu ele.

JavaScript
test('catalogul gol afișează mesajul de stare goală', async ({ page }) => {
  await page.route('**/api/products*', route =>
    route.fulfill({ status: 200, json: [] })
  );

  await page.goto('/produse');

  await expect(page.getByText('Nu am găsit produse')).toBeVisible();
  await expect(page.getByTestId('product-card')).toHaveCount(0);
  await expect(page.getByRole('button', { name: 'Resetează filtrele' })).toBeVisible();
});

Detalii:

  • Ruta trebuie înregistrată înainte de acțiunea care trimite cererea, aici goto. Altfel cererea pleacă spre serverul real.
  • Opțiunea json (din versiunea 1.29) serializează obiectul și setează Content-Type: application/json. Alternativ: body cu text și contentType.
  • Glob-ul **/api/products* prinde și variantele cu query string (?page=1). Pentru precizie mai mare, un regex sau o funcție care primește URL.
  • Ruta e valabilă pentru acea pagină; context.route o aplică tuturor paginilor din context, inclusiv popup-urilor.

Astfel testezi stări greu de produs cu date reale: listă goală, o listă foarte lungă, un produs fără imagine, un preț cu multe zecimale. Fără mock, ar trebui să manipulezi baza de date partajată, ceea ce strică alte teste care rulează în paralel.

Limita: testul nu mai verifică backend-ul. Starea goală reală (filtre fără rezultate) o acoperi separat, la nivel de API.

Ce urmărește intervievatorul: Întrebare de bază despre mock-uri de rețea. Greșeala tipică este înregistrarea rutei după goto, iar testul trece sau pică în funcție de viteză.

65 Junior

Care e diferența dintre route.fulfill, route.continue, route.abort și route.fallback? Dă un caz pentru fiecare.

Răspuns scurt: fulfill răspunde cu un răspuns inventat, continue trimite cererea mai departe la server (eventual modificată), abort o anulează ca pe o eroare de rețea, iar fallback o pasează următorului handler înregistrat pentru aceeași rută.

Fiecare handler de rută trebuie să termine cererea într-unul din aceste moduri:

  • route.fulfill({ status, json, body, headers }): serverul nu mai e contactat. Caz: simulezi o eroare 500 la plasarea comenzii, ca să verifici mesajul pentru utilizator.
JavaScript
await page.route('**/api/orders', r => r.fulfill({ status: 500, json: { error: 'Internal' } }));
  • route.continue({ headers, postData, method, url }): cererea pleacă la server, opțional modificată. Caz: adaugi un header de test sau schimbi un parametru.
JavaScript
await page.route('**/api/**', r => r.continue({
  headers: { ...r.request().headers(), 'x-test-run': 'ci' },
}));
  • route.abort(cod): cererea eșuează ca eroare de rețea ('failed' implicit, sau 'timedout', 'internetdisconnected' etc.). Caz: verifici comportamentul offline, sau blochezi resurse irelevante (analytics, fonturi, imagini mari) ca testele să fie mai rapide și mai stabile.
JavaScript
await page.route(/google-analytics|hotjar/, r => r.abort());
await page.route('**/*.{png,jpg,webp}', r => r.abort());
  • route.fallback(): nu decide; lasă cererea următorului handler potrivit (handler-ele înregistrate mai târziu rulează primele). Caz: un handler general care loghează toate cererile, combinat cu handler-e specifice pe anumite rute.

Dacă un handler nu apelează niciuna dintre metode, cererea rămâne agățată și testul expiră. Pentru eliminarea unei rute există page.unroute() sau page.unrouteAll().

Ce urmărește intervievatorul: Se verifică dacă știi toate ramurile interceptării. Mulți cunosc doar fulfill și nu știu că blocarea resurselor terțe poate stabiliza suita.

Eroarea, în practică:route.continue: Route is already handled!page.goto: net::ERR_FAILED

66 Junior

Cum verifici că formularul de checkout trimite la server exact datele completate în UI?

Răspuns scurt: Pornești page.waitForRequest cu un predicat pe URL și metodă înainte de click, apoi citești corpul cu request.postDataJSON() și îl compari cu ce ai completat. Poți face asta fără să mock-uiești răspunsul.

Un test de UI verifică de obicei efectul vizibil. Uneori bug-ul e însă în datele trimise: un câmp omis, un telefon trimis cu spații, o țară greșită. Interceptarea cererii te lasă să verifici contractul dintre UI și backend.

JavaScript
test('checkout trimite adresa completă', async ({ page }) => {
  await page.goto('/checkout');
  await page.getByLabel('Nume').fill('Ana Pop');
  await page.getByLabel('Telefon').fill('0712 345 678');
  await page.getByLabel('Oraș').fill('Cluj-Napoca');
  await page.getByLabel('Livrare rapidă').check();

  const reqPromise = page.waitForRequest(r =>
    r.url().endsWith('/api/orders') && r.method() === 'POST'
  );
  await page.getByRole('button', { name: 'Plasează comanda' }).click();
  const req = await reqPromise;

  expect(req.postDataJSON()).toMatchObject({
    name: 'Ana Pop',
    phone: '0712345678',
    city: 'Cluj-Napoca',
    shipping: 'express',
  });
  expect(req.headers()['content-type']).toContain('application/json');
});

Observații:

  • Promisiunea se creează înainte de click, ca să nu ratezi cererea.
  • postDataJSON() parsează corpul JSON (sau un formular application/x-www-form-urlencoded); pentru alte formate există postData().
  • toMatchObject verifică doar câmpurile care contează, nu pică dacă se adaugă altele.
  • Aici telefonul e normalizat în UI înainte de trimitere; testul documentează această regulă.

Alternativ, poți colecta toate cererile cu page.on('request', ...), util pentru a verifica și ce nu se trimite (de exemplu că nu pleacă două cereri la dublu-click).

Ce urmărește intervievatorul: Verifică dacă știi să testezi la granița dintre frontend și backend. Greșeala tipică este verificarea doar a mesajului de succes din UI.

67 Mid

Cum modifici doar un câmp din răspunsul real al serverului, de exemplu stocul unui produs, ca să testezi mesajul „Stoc epuizat”?

Răspuns scurt: În handler-ul rutei chemi route.fetch() ca să obții răspunsul real, modifici JSON-ul și răspunzi cu route.fulfill({ response, json }). Restul datelor rămân reale, deci testul e mai apropiat de producție decât un mock complet.

Un mock complet trebuie întreținut: dacă API-ul adaugă câmpuri, mock-ul rămâne în urmă. Modificarea răspunsului real păstrează tot ce nu te interesează exact cum îl trimite serverul.

JavaScript
test('produsul fără stoc dezactivează butonul', async ({ page }) => {
  await page.route('**/api/products/tricou-alb', async route => {
    const response = await route.fetch();          // cererea reală
    const json = await response.json();
    json.stock = 0;                                 // singura modificare
    await route.fulfill({ response, json });        // status și headere reale
  });

  await page.goto('/produs/tricou-alb');
  await expect(page.getByText('Stoc epuizat')).toBeVisible();
  await expect(page.getByRole('button', { name: 'Adaugă în coș' })).toBeDisabled();
});

route.fetch() există din versiunea 1.29 și acceptă aceleași opțiuni ca continue (headere, URL, metodă), deci poți modifica și cererea. fulfill({ response }) preia statusul și headerele răspunsului real, iar json suprascrie corpul.

Cazuri bune pentru această tehnică:

  • valori limită pe un câmp (stoc 0, preț foarte mare, nume foarte lung);
  • un flag de funcționalitate întors de backend;
  • un câmp lipsă, ca să vezi dacă UI-ul tratează undefined fără să se blocheze;
  • dată în trecut sau în viitor pentru o ofertă.

Limita rămâne aceeași ca la orice mock: testezi reacția UI-ului la o stare, nu și faptul că backend-ul o produce corect. Asta se verifică separat, la nivel de API.

Ce urmărește intervievatorul: Arată dacă știi tehnica intermediară dintre mock complet și date reale. Mulți nu știu de route.fetch().

68 Mid

Cum verifici structura unui răspuns JSON într-un test API, nu doar câteva valori?

Răspuns scurt: Pentru verificări punctuale folosești toMatchObject cu matcheri asimetrici (expect.any, expect.arrayContaining). Pentru contractul complet validezi răspunsul cu o schemă JSON (de exemplu cu biblioteca Ajv) sau cu o schemă Zod.

Statusul 200 nu spune nimic despre forma datelor. Un câmp redenumit (price devenit amount) strică frontend-ul, dar trece de un test care verifică doar statusul.

Varianta 1, matcheri asimetrici, bună pentru verificări de formă în teste obișnuite:

JavaScript
const res = await request.get('/api/products?limit=3');
expect(res.status()).toBe(200);
const body = await res.json();

expect(body).toMatchObject({
  total: expect.any(Number),
  items: expect.any(Array),
});
expect(body.items).toHaveLength(3);
for (const p of body.items) {
  expect(p).toEqual({
    id: expect.any(Number),
    name: expect.any(String),
    price: expect.any(Number),
    stock: expect.any(Number),
    image: expect.stringMatching(/^https:\/\//),
  });
}

toEqual cu obiectul complet pică dacă apare un câmp neprevăzut; toMatchObject nu. Alegi în funcție de cât de strict vrei contractul.

Varianta 2, schemă JSON cu Ajv, bună când contractul e mare sau există deja o specificație OpenAPI:

JavaScript
import Ajv from 'ajv';
const ajv = new Ajv({ allErrors: true });
const validate = ajv.compile(productListSchema);

expect(validate(body), JSON.stringify(validate.errors, null, 2)).toBe(true);

Mesajul de eroare include lista de abateri, deci vezi exact ce câmp lipsește. Avantajul schemei: poate fi generată din OpenAPI și reutilizată, iar regulile (câmpuri obligatorii, tipuri, formate, additionalProperties: false) sunt într-un singur loc.

Verifici și headerele relevante, cum ar fi content-type, și timpul de răspuns doar ca indicator orientativ, nu ca prag strict în teste funcționale.

Ce urmărește intervievatorul: Se verifică dacă știi să testezi contractul unui API. Greșeala tipică este oprirea la status și la un singur câmp.

Eroarea, în practică:expect(received).toHaveProperty(path)expect(received).toMatchObject(expected)

69 Mid

Cum testezi că aplicația te trimite la login când sesiunea expiră în timpul folosirii?

Răspuns scurt: Pornești cu utilizatorul logat, apoi simulezi expirarea: ștergi cookie-urile contextului cu context.clearCookies() sau faci ca următoarea cerere API să întoarcă 401 printr-o rută. Verifici redirecționarea la login, mesajul și întoarcerea pe pagina inițială după relogare.

Așteptarea expirării reale (de exemplu 30 de minute) nu e o opțiune. Ai două tehnici, care verifică lucruri ușor diferite.

1. Sesiune invalidată în browser: verifici reacția la o sesiune care nu mai există.

JavaScript
test('cookie-ul șters trimite la login', async ({ page, context }) => {
  await page.goto('/cont/comenzi');           // logat prin storageState
  await context.clearCookies();
  await page.reload();
  await expect(page).toHaveURL(/\/login\?redirect=%2Fcont%2Fcomenzi/);
});

Din versiunea 1.43, clearCookies acceptă filtre ({ name: 'session' }), ca să ștergi doar cookie-ul de sesiune.

2. 401 simulat de API în timpul folosirii: verifici ce face SPA-ul când un apel eșuează pe parcurs.

JavaScript
test('401 pe salvare afișează mesajul și cere relogare', async ({ page }) => {
  await page.goto('/cont/profil');
  await page.route('**/api/profile', r => r.fulfill({ status: 401, json: { error: 'expired' } }));
  await page.getByLabel('Telefon').fill('0712345678');
  await page.getByRole('button', { name: 'Salvează' }).click();
  await expect(page.getByText('Sesiunea a expirat')).toBeVisible();
  await expect(page).toHaveURL(/\/login/);
});

Ce mai merită verificat: că după relogare utilizatorul revine pe pagina de unde a plecat, că datele nesalvate sunt tratate conform cerinței și că logout-ul invalidează sesiunea și pe server (o cerere API cu vechiul cookie trebuie să primească 401). Acest ultim punct e un test de securitate simplu, adesea omis.

Ce urmărește intervievatorul: Scenariu realist de mid. Se urmărește dacă știi să simulezi timpul fără să aștepți și dacă te gândești și la verificarea pe server.

70 Senior

Echipa a mock-uit aproape toate apelurile API în testele E2E, iar testele sunt verzi, dar în producție apar erori de integrare. Ce s-a întâmplat și cum echilibrezi?

Răspuns scurt: Mock-urile au rămas în urmă față de API-ul real (contract drift), deci testele verifică o lume care nu mai există. Echilibrezi păstrând E2E reale pentru fluxurile critice, mock-uri doar pentru stări greu de produs și verificări de contract între frontend și backend.

Un mock este o presupunere despre cum răspunde serverul. Când backend-ul redenumește un câmp, schimbă un cod de eroare sau adaugă o validare, mock-ul nu se schimbă singur. Testele continuă să treacă, iar integrarea reală se strică exact acolo unde ai crede că ești acoperit.

Cum echilibrezi:

  • Fluxurile critice rulează pe backend real: login, căutare, coș, plată în sandbox. Puține teste, dar fără mock-uri.
  • Mock-urile au un scop declarat: stări rare sau greu de produs (500, timeout, listă goală, valori limită), nu „ca să meargă mai repede”.
  • Modificarea răspunsurilor reale (route.fetch() și schimbarea unui câmp) în locul mock-urilor scrise de mână, ca restul datelor să rămână reale.
  • Mock-uri derivate din contract: răspunsurile sunt generate sau validate față de schema OpenAPI, iar o schimbare în schemă strică explicit testele.
  • Contract testing (de exemplu Pact): consumatorul (frontend-ul) publică așteptările, iar furnizorul le verifică în pipeline-ul lui. O schimbare incompatibilă pică la backend, înainte de deploy.
  • Teste API separate pe endpoint-urile pe care frontend-ul se bazează.

Ca proces: când un bug de integrare scapă, întrebi la retrospectivă ce test ar fi trebuit să-l prindă și la ce nivel, apoi adaugi acel test. Și urmărești, ca semnal, câte teste E2E rulează complet fără mock-uri.

Ce urmărește intervievatorul: Întrebare de senior despre strategie. Se verifică dacă înțelegi că mock-urile mută riscul, nu îl elimină.

71 Senior

Ce sunt fișierele HAR și cum le folosești în Playwright pentru a rula teste cu răspunsuri înregistrate?

Răspuns scurt: Un HAR (HTTP Archive) este un fișier JSON cu cererile și răspunsurile unei sesiuni de navigare. Playwright îl poate înregistra și apoi servi cu page.routeFromHAR, ca testele să ruleze pe răspunsuri fixe, fără backend.

HAR este un format standard, exportat și de DevTools. În Playwright are două utilizări.

Înregistrare, cu opțiunea update: true, prima dată sau când vrei să reîmprospătezi datele:

JavaScript
test('catalog din HAR', async ({ page }) => {
  await page.routeFromHAR('hars/catalog.har', {
    url: '**/api/**',
    update: true,          // înregistrează de la serverul real
  });
  await page.goto('/produse');
  await expect(page.getByTestId('product-card').first()).toBeVisible();
});

Redare, fără update: cererile care se potrivesc cu url sunt servite din fișier. Opțiunea notFound decide ce faci cu cererile care nu sunt în HAR: 'abort' (implicit) sau 'fallback' (merg la rețea).

Când e util:

  • teste vizuale sau de UI care au nevoie de date stabile și realiste, nu de mock-uri scrise de mână;
  • dezvoltarea testelor pentru un backend încă instabil;
  • reproducerea unui bug raportat cu un HAR de la utilizator (după ce elimini datele personale și tokenurile).

Riscuri, de spus la interviu:

  • Fișierele învechesc, ca orice mock. Trebuie reînregistrate periodic și verificate în code review.
  • Conțin date sensibile: cookie-uri, tokenuri, date personale. Nu le pui în repository fără curățare.
  • Potrivirea cererilor se face pe URL și metodă, iar pentru POST și pe corp; diferențe mici (un timestamp în query) duc la ratarea potrivirii.

Pentru suita principală, HAR-ul e o unealtă de nișă; nu înlocuiește testele pe backend real.

Ce urmărește intervievatorul: Întrebare de senior despre unelte avansate. Se urmărește dacă vezi și riscurile, în special datele sensibile din fișiere.

72 Senior

Cum combini API-ul și UI-ul în același test ca să verifici plasarea unei comenzi? Ce verifici prin API și ce prin UI?

Răspuns scurt: Pregătești starea prin API (utilizator, produse în coș), faci prin UI doar acțiunea testată (plasarea comenzii) și verifici efectul în ambele: mesajul și pagina comenzii în UI, iar datele salvate (total, produse, status) prin API. Curățenia o faci tot prin API.

Ideea: UI-ul se folosește doar pentru ce testezi efectiv; tot restul e mai rapid și mai stabil prin API.

JavaScript
test('plasarea comenzii salvează totalul corect', async ({ page, request, account }) => {
  // Arrange prin API
  await request.post('/api/cart/items', {
    headers: { Authorization: `Bearer ${account.token}` },
    data: { sku: 'TRC-ALB', qty: 2 },
  });

  // Act prin UI
  await page.goto('/checkout');
  await page.getByLabel('Plată ramburs').check();
  await page.getByRole('button', { name: 'Plasează comanda' }).click();

  // Assert în UI
  const confirmare = page.getByRole('alert');
  await expect(confirmare).toHaveText(/Comanda #\d+ a fost plasată/);
  const id = (await confirmare.textContent()).match(/#(\d+)/)[1];

  // Assert prin API
  const res = await request.get(`/api/orders/${id}`, {
    headers: { Authorization: `Bearer ${account.token}` },
  });
  expect(await res.json()).toMatchObject({
    status: 'pending',
    total: 99.98,
    items: [{ sku: 'TRC-ALB', qty: 2 }],
  });
});

Ce verifici unde:

  • UI: ce vede utilizatorul (confirmarea, totalul afișat, navigarea), pentru că asta e experiența testată.
  • API: ce s-a salvat efectiv, inclusiv câmpuri care nu apar în UI (status intern, metoda de plată). Așa prinzi bug-uri de tipul „UI-ul arată corect, dar se salvează altceva”.

Decizii de design de senior:

  • Dacă backend-ul procesează asincron (cozi), verificarea prin API se face cu expect.poll, nu cu un singur GET.
  • Datele create (comanda, contul) se șterg în teardown-ul fixture-ului, nu la finalul testului.
  • Nu verifici direct în baza de date decât dacă nu există API; un test legat de schema tabelelor se strică la orice migrare.

Ce urmărește intervievatorul: Arată dacă știi să proiectezi teste hibride eficiente. Greșeala tipică este fie totul prin UI, fie verificarea finală doar în UI.

Teste instabile, debugging și artefacte

73 Junior

Un test a picat cu mesajul de mai jos. Ce îți spune și care sunt primii pași?

Error: Timed out 5000ms waiting for expect(locator).toHaveText(expected)

Locator: getByTestId('cart-total')
Expected string: "149,98 lei"
Received string: "74,99 lei"
Call log:
  - waiting for getByTestId('cart-total')
  - locator resolved to <span data-testid="cart-total">74,99 lei</span>
  - unexpected value "74,99 lei"

Răspuns scurt: Elementul a fost găsit, dar totalul a rămas „74,99 lei” timp de 5 secunde, deci problema nu e locatorul sau sincronizarea, ci starea: al doilea produs nu a ajuns în coș sau totalul e calculat greșit. Verifici pașii anteriori în trace.

Citirea mesajului, pe părți:

  • „Timed out 5000ms waiting for expect(...)”: a expirat expect.timeout, nu timeout-ul testului. Aserțiunea a reîncercat 5 secunde.
  • „locator resolved to ...”: elementul există și e unic. Deci nu e un locator greșit și nici strict mode.
  • „Received string: 74,99 lei” față de „149,98”: exact jumătate, adică prețul unui singur produs din cele două.

Ipoteze, în ordine:

  • al doilea „Adaugă în coș” nu a avut efect (click prea devreme, buton dezactivat, cerere eșuată);
  • cantitatea nu s-a actualizat (de exemplu fill('2') într-un câmp care se recalculează abia la blur);
  • un bug real în calculul totalului.

Pași concreți:

  • Deschizi trace-ul (npx playwright show-trace) și te uiți la pasul de adăugare: DOM-ul înainte și după, cererile de rețea (a plecat al doilea POST /api/cart? ce status a avut?), erorile din consolă.
  • Verifici dacă eșecul e constant sau intermitent (rulezi de mai multe ori cu --repeat-each=10). Constant indică mai degrabă bug sau schimbare de comportament; intermitent, sincronizare.
  • Reproduci manual aceiași pași. Dacă și manual totalul e greșit, raportezi bug-ul cu trace-ul atașat.

Ce nu faci: mărești timeout-ul. Valoarea primită nu „întârzie”, e pur și simplu alta.

Ce urmărește intervievatorul: Se verifică dacă știi să citești un raport de eșec înainte de a schimba codul. Mulți sar direct la mărirea timeout-ului.

Eroarea, în practică:expect(locator).toHaveText(expected) failed

74 Junior

Ce opțiuni ai pentru capturi de ecran, video și trace în Playwright și cum le configurezi pentru CI?

Răspuns scurt: În use setezi screenshot (off, on, only-on-failure), video (off, on, retain-on-failure, on-first-retry) și trace (off, on, retain-on-failure, on-first-retry și altele). Pe CI se folosesc de obicei variantele „doar la eșec” sau „la primul retry”, ca să nu încetinești suita.

Configurare tipică:

JavaScript
export default defineConfig({
  retries: process.env.CI ? 2 : 0,
  use: {
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
    trace: 'on-first-retry',
  },
});

Ce înseamnă fiecare:

  • Captura: o imagine a paginii la finalul testului. only-on-failure o păstrează doar dacă testul pică. Ieftină, utilă pentru o primă privire.
  • Video: înregistrarea întregului test. retain-on-failure înregistrează mereu, dar păstrează doar la eșec, deci costul de înregistrare există pentru toate testele. on-first-retry înregistrează doar la reluare. Se poate seta și dimensiunea: video: { mode: 'retain-on-failure', size: { width: 1280, height: 720 } }.
  • Trace: cel mai bogat artefact (acțiuni, DOM pentru fiecare pas, rețea, consolă, surse). on-first-retry e recomandarea din configurația generată: când un test pică și e reluat, a doua încercare produce trace, iar tu vezi exact ce s-a întâmplat. retain-on-failure păstrează trace la orice eșec, cu cost de înregistrare la fiecare test. Mai există on-all-retries și retain-on-first-failure.

Toate ajung în test-results/ și sunt legate în raportul HTML. Pe CI trebuie încărcate ca artefacte, altfel dispar odată cu runner-ul.

În cod, pentru o captură intermediară: await page.screenshot({ path: testInfo.outputPath('dupa-filtru.png'), fullPage: true }) sau atașată direct în raport cu testInfo.attach.

Ce urmărește intervievatorul: Verifică dacă ai configurat un proiect pentru depanare pe CI. Greșeala tipică este trace: 'on' pentru toată suita, care o încetinește și umple spațiul.

75 Junior

Ce conține un trace Playwright și cum îl folosești ca să afli de ce a picat un test pe CI?

Răspuns scurt: Trace-ul conține lista acțiunilor cu durata lor, instantanee DOM înainte și după fiecare acțiune, cererile de rețea, mesajele din consolă, erorile și codul sursă al testului. Îl deschizi cu npx playwright show-trace trace.zip sau în trace.playwright.dev și refaci pas cu pas ce s-a întâmplat.

Trace-ul e o arhivă .zip produsă de rulare. Îl găsești în raportul HTML (secțiunea Traces a testului) sau în artefactele CI.

BASH
npx playwright show-report               # apoi click pe trace-ul testului
npx playwright show-trace test-results/cos-total/trace.zip

Alternativ, îl încarci în trace.playwright.dev, care rulează local, în browser, fără să trimită fișierul pe un server.

Ce vezi în Trace Viewer:

  • Cronologia acțiunilor, cu durata fiecăreia. O acțiune care durează mult arată unde a așteptat Playwright.
  • Instantanee DOM (Before, Action, After) pentru fiecare pas. Nu sunt imagini, ci DOM-ul real, deci poți inspecta elementele, dimensiunile, clasele.
  • Locul click-ului, marcat pe instantaneu: vezi dacă a nimerit un overlay.
  • Rețea: fiecare cerere cu status, headere, corp și timp. Aici apare des cauza: un 500 sau o cerere care nu a plecat deloc.
  • Consola și erorile JavaScript din pagină.
  • Sursa testului, cu linia curentă evidențiată, plus erorile aserțiunilor.
  • Atașamentele și pașii din test.step.

Un proces de depanare: pornești de la eroare, mergi înapoi până la ultima acțiune după care starea arată cum te așteptai, apoi compari instantaneul și cererile din pasul următor. Pentru teste care trec local și pică pe CI, compari cu un trace local generat cu --trace on.

Trace-ul poate conține date sensibile (cookie-uri, tokenuri din headere), deci se tratează ca orice artefact intern.

Ce urmărește intervievatorul: Se verifică dacă folosești efectiv unealta principală de depanare. Candidații care nu au deschis niciodată un trace răspund vag „mă uit la loguri”.

76 Junior

La ce folosește test.step și cum arată un test structurat cu pași?

Răspuns scurt: test.step grupează acțiunile unui test în pași cu nume, vizibili în raportul HTML, în trace și în mesajul de eroare. Testul se citește ca un caz de test, iar la eșec vezi imediat la ce pas s-a oprit.

Un test fără pași apare în raport ca o listă lungă de acțiuni (click, fill, expect). Cu test.step, acțiunile se grupează pe intenție:

JavaScript
test('client nou finalizează prima comandă', async ({ page }) => {
  await test.step('se înregistrează', async () => {
    await page.goto('/inregistrare');
    await page.getByLabel('Email').fill(`ana.${Date.now()}@test.ro`);
    await page.getByLabel('Parolă', { exact: true }).fill('Parola!123');
    await page.getByRole('button', { name: 'Creează cont' }).click();
    await expect(page.getByText('Cont creat')).toBeVisible();
  });

  const total = await test.step('adaugă două produse în coș', async () => {
    // ...
    return await page.getByTestId('cart-total').textContent();
  });

  await test.step('plasează comanda', async () => {
    // ...
    await expect(page.getByRole('alert')).toContainText(total);
  });
});

Proprietăți utile:

  • test.step întoarce valoarea funcției, deci poți transmite date între pași.
  • Pașii se pot imbrica.
  • Opțiunea { box: true } (din 1.39) face ca eroarea să indice linia pasului, nu linia din interiorul unei funcții ajutătoare, util pentru pași definiți în Page Objects.
  • test.step.skip (din 1.50) marchează un pas sărit.
  • În Page Objects, metodele pot fi învelite în pași cu numele acțiunii, ca raportul să se citească în limbajul domeniului.

Pașii nu schimbă execuția, deci nu sunt o alternativă la teste independente. Dacă un pas pică, următorii nu mai rulează.

Ce urmărește intervievatorul: Verifică dacă scrii teste citibile în raport. Greșeala tipică este folosirea console.log pentru a marca etapele.

77 Junior

Cum funcționează retry-urile în Playwright și ce înseamnă un test marcat flaky în raport?

Răspuns scurt: Cu retries: N, un test picat se reia de până la N ori, într-un worker nou. Dacă pică și apoi trece la o reluare, e marcat flaky: rularea e considerată reușită, dar testul are o problemă care trebuie investigată, nu ignorată.

Configurare: retries: process.env.CI ? 2 : 0 în config, --retries=2 din linia de comandă sau test.describe.configure({ retries: 2 }) pentru un grup.

Ce se întâmplă la eșec:

  • workerul în care a picat testul e oprit, iar testul se reia într-un worker nou, cu browser nou, ca să nu moștenească stare stricată;
  • hook-urile beforeAll rulează din nou în workerul nou;
  • testInfo.retry arată numărul încercării, util pentru diagnostic (de exemplu să atașezi mai multe date la retry);
  • trace-ul cu on-first-retry se înregistrează exact la această reluare.

Categorii în raport:

  • passed: a trecut la prima încercare;
  • flaky: a picat cel puțin o dată, apoi a trecut;
  • failed: a picat la toate încercările.

Un test flaky nu face pipeline-ul roșu, și tocmai aici e capcana. Retry-urile sunt o plasă de siguranță pentru instabilități de mediu ocazionale, nu o soluție. Un test care trece doar uneori poate ascunde:

  • o problemă de sincronizare în test;
  • o condiție de cursă reală în aplicație, pe care o vor simți și utilizatorii;
  • date partajate între teste.

Bune practici: retry-uri doar pe CI, nu local (local vrei să vezi problema), urmărirea listei de teste flaky după fiecare rulare și tratarea lor ca bug-uri, cu responsabil. Opțiunea --fail-on-flaky-tests (din 1.45) face rularea să pice dacă apare vreun test flaky, pentru echipele care vor toleranță zero.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul și riscul lui. Greșeala tipică este mărirea numărului de retry-uri până când suita e verde.

Eroarea, în practică:Test flaky: trece uneori, pică alteori

78 Mid

De ce e instabil testul următor și cum îl faci determinist?

JavaScript
test('banner-ul de Crăciun apare în decembrie', async ({ page }) => {
  await page.goto('/');
  const luna = new Date().getMonth();
  if (luna === 11) {
    await expect(page.getByTestId('xmas-banner')).toBeVisible();
  } else {
    await expect(page.getByTestId('xmas-banner')).toBeHidden();
  }
});

Răspuns scurt: Rezultatul depinde de data reală: testul verifică altceva în funcție de lună și de fusul orar al runner-ului, iar pe 31 decembrie seara două mașini pot ajunge la luni diferite. Fixezi ceasul paginii cu page.clock și scrii două teste separate, fiecare cu o dată fixă.

Probleme:

  • Dependența de timpul real: în 11 luni din 12 se testează doar ramura „ascuns”. Un bug în afișarea bannerului se descoperă abia în decembrie.
  • Ceasul testului nu e ceasul paginii: new Date() rulează în Node, pe runner, iar bannerul e decis în browser sau pe server. Fusurile orare diferite (runner CI în UTC, browserul cu timezoneId din config) pot da luni diferite la granițe.
  • Logică în test: un if care decide ce verifici înseamnă că testul nu are un rezultat așteptat unic.

Varianta deterministă, cu API-ul page.clock (disponibil din versiunea 1.45):

JavaScript
test.describe('banner de Crăciun', () => {
  test.use({ timezoneId: 'Europe/Bucharest' });

  test('apare pe 15 decembrie', async ({ page }) => {
    await page.clock.setFixedTime(new Date('2026-12-15T10:00:00+02:00'));
    await page.goto('/');
    await expect(page.getByTestId('xmas-banner')).toBeVisible();
  });

  test('nu apare pe 15 noiembrie', async ({ page }) => {
    await page.clock.setFixedTime(new Date('2026-11-15T10:00:00+02:00'));
    await page.goto('/');
    await expect(page.getByTestId('xmas-banner')).toBeHidden();
  });
});

setFixedTime face ca Date.now() și new Date() din pagină să întoarcă mereu aceeași valoare. page.clock.install() împreună cu fastForward sau runFor controlează și timerele, util pentru sesiuni care expiră sau pentru numărătoare inversă.

Limita: page.clock controlează doar timpul din browser. Dacă bannerul e decis pe server, ai nevoie de un mecanism de test în backend (o dată injectabilă), de cerut developerilor.

Ce urmărește intervievatorul: Întrebare de cod despre una dintre cele mai frecvente surse de instabilitate. Se urmărește dacă recunoști dependența de timp și cunoști page.clock.

79 Mid

Cum funcționează testarea vizuală cu toHaveScreenshot și care sunt capcanele ei?

Răspuns scurt: Prima rulare creează imaginea de referință, iar rulările următoare compară pixel cu pixel captura curentă cu referința, cu o toleranță configurabilă. Capcanele: diferențe de randare între sisteme de operare, conținut dinamic, animații și referințe actualizate fără verificare.

JavaScript
test('pagina de produs arată corect', async ({ page }) => {
  await page.goto('/produs/tricou-alb');
  await expect(page).toHaveScreenshot('produs.png', {
    fullPage: true,
    mask: [page.getByTestId('recomandari'), page.getByTestId('data-livrare')],
    maxDiffPixelRatio: 0.01,
  });
  await expect(page.getByTestId('price')).toHaveScreenshot('pret.png');
});

Mecanismul:

  • La prima rulare nu există referință: testul pică și salvează captura ca referință, în folderul <fișier>.spec.js-snapshots/, cu numele care include proiectul și platforma (de exemplu produs-chromium-linux.png).
  • Apoi Playwright face capturi repetate până când două consecutive sunt identice (pagina s-a stabilizat), le compară cu referința și, la diferențe, salvează în raport imaginea așteptată, cea primită și diferența.
  • npx playwright test --update-snapshots regenerează referințele.

Capcane:

  • Platforma: fonturile și antialiasing-ul diferă între macOS, Windows și Linux. De aceea referințele sunt per platformă și se generează, de obicei, în același container Docker în care rulează CI-ul.
  • Conținut dinamic: date, reclame, recomandări. Se maschează cu mask sau se fixează (mock-uri, page.clock).
  • Animațiile: toHaveScreenshot le dezactivează implicit (animations: 'disabled') și ascunde cursorul text, dar animațiile JS proprii trebuie oprite separat.
  • Toleranța: maxDiffPixels, maxDiffPixelRatio, threshold. Prea mică produce eșecuri false, prea mare ascunde schimbări reale.
  • Actualizarea în orb: rularea cu --update-snapshots fără să te uiți la diferențe transformă un bug în referință. Schimbările de referință trec prin code review, ca orice cod.

Testele vizuale sunt bune pe componente stabile și pagini cheie, nu pe toată aplicația.

Ce urmărește intervievatorul: Se verifică experiența practică cu testarea vizuală. Mulți nu știu că referințele depind de sistemul de operare și se miră că testele pică pe CI.

Eroarea, în practică:expect(page).toHaveScreenshot(expected) failed

80 Senior

Testele trec toate când rulezi cu un singur worker, dar cu opt workeri pică aleatoriu teste diferite la fiecare rulare. Ce cauți?

Răspuns scurt: Cauți stare partajată între teste: aceleași conturi sau date folosite în paralel, teste care modifică setări globale, ordine presupusă, limite de rată ale serverului sau un mediu care nu face față încărcării. Confirmi ipoteza reducând și crescând numărul de workeri și citind trace-urile eșecurilor.

Faptul că eșecurile apar doar în paralel și „se mută” între teste e un semnal clar: problema nu e în testele individuale, ci în interacțiunea dintre ele. Cauzele, în ordinea frecvenței:

  • Date partajate: toate testele folosesc același utilizator ana@test.ro. Un test golește coșul în timp ce altul verifică totalul. Soluție: utilizator per worker (fixture cu workerIndex) sau date create per test.
  • Stare globală în backend: un test schimbă un setting global (moneda, un feature flag, prețul unui produs folosit de toate testele). Soluție: datele modificate să fie create de testul respectiv; setările globale testate într-un proiect separat, rulat serial.
  • Unicitate ratată: nume generate cu Date.now() care se ciocnesc între workeri în aceeași milisecundă. Soluție: includerea workerIndex sau a unui UUID.
  • Limitări ale serverului: rate limiting la login, un pool mic de conexiuni la baza de date, un mediu de test subdimensionat. Simptom: răspunsuri 429 sau 503 în trace-uri.
  • Resurse ale mașinii: opt browsere pe un runner cu două nuclee devin lente, iar timeout-urile încep să expire.
  • Fișiere comune: teste care scriu în aceeași cale (descărcări, rapoarte). Soluție: testInfo.outputPath().

Cum confirmi: rulezi cu --workers=2, 4, 8 și vezi dacă rata de eșec crește; cauți în trace-uri coduri 429/5xx; grupezi eșecurile după datele folosite. Apoi corectezi cauza, nu reduci definitiv workerii la 1.

Ce urmărește intervievatorul: Întrebare de senior despre depanarea suitelor paralele. Se urmărește o listă de ipoteze verificabile, nu „pun retry-uri”.

Eroarea, în practică:Test flaky: trece uneori, pică alteori

81 Senior

Un test trece mereu local, dar pică frecvent în CI. Cum îl depanezi?

Răspuns scurt: Compari cele două medii (headless, viewport, fus orar, limbă, resurse, date, paralelism), descarci trace-ul de pe CI, încerci să reproduci local condițiile CI-ului (headless, CPU încetinit, aceeași imagine Docker) și corectezi cauza, nu adaugi pauze.

Model de răspuns structurat:

1. Strângi dovezile. Descarci artefactele din CI: trace, captură, video, logurile serverului dacă există. Notezi dacă eșecul e la același pas sau variază și cât de des apare.

2. Compari mediile. Diferențele tipice dintre local și CI:

  • headless pe CI, headed local;
  • alt viewport sau altă densitate de pixeli;
  • fus orar și limbă (CI în UTC și en-US, local Europe/Bucharest și ro-RO), care schimbă formatarea datelor și a prețurilor;
  • mai puține resurse: pagina se încarcă mai lent, deci problemele de sincronizare apar mai des;
  • mai mulți workeri în paralel și date partajate;
  • altă versiune de browser sau de dependențe (lipsa package-lock.json sau npm install în loc de npm ci);
  • mediu de test diferit, cu alte date sau feature flags.

3. Reproduci local condițiile. Rulezi headless, cu aceiași workeri, cu timezoneId și locale setate explicit, în imaginea Docker folosită de CI (mcr.microsoft.com/playwright) și, la nevoie, cu CPU încetinit sau --repeat-each=20.

4. Repari cauza: o așteptare pe semnalul corect, date izolate, valori explicite în config pentru locale și timezoneId. Fixarea acestor valori în config face testele identice între mașini.

5. Previi: adaugi în config ce ai învățat și documentezi cazul pentru echipă.

Rezultatul arătat la interviu: un test care trece constant în ambele medii și o cauză explicată, nu un waitForTimeout adăugat „pentru CI”.

Ce urmărește intervievatorul: Întrebare de situație foarte frecventă. Se urmărește metoda: dovezi, ipoteze, reproducere, corectare. Răspunsul slab este mărirea timeout-ului doar pe CI.

Eroarea, în practică:Test flaky: trece uneori, pică alteori

82 Senior

Echipa a început să ignore pipeline-ul roșu pentru că „testele E2E pică oricum”. Ce faci?

Răspuns scurt: Tratezi încrederea în suită ca pe o problemă de prioritate: separi imediat testele instabile într-o carantină vizibilă, repari sau ștergi testele cu probleme, faci ca pipeline-ul principal să fie roșu doar pentru eșecuri reale și urmărești public progresul.

Model de răspuns:

Situația. Când roșul devine normal, un bug real trece neobservat printre eșecurile „obișnuite”. Suita costă timp, dar nu mai protejează nimic.

Acțiuni imediate (zile, nu luni).

  • Aduni istoricul ultimelor rulări și clasifici eșecurile: bug real, test instabil, problemă de mediu.
  • Mut testele instabile cunoscute într-o carantină: un tag (@carantina) rulat într-un job separat care nu blochează merge-ul, dar e vizibil. Fiecare test din carantină are un tichet și un responsabil.
  • Pipeline-ul principal rămâne cu testele de încredere și devine regula: roșu înseamnă oprire.

Acțiuni de fond.

  • Repari cauzele comune descoperite (date partajate, sincronizări greșite, mediu instabil), care de obicei afectează mai multe teste deodată.
  • Ștergi testele care nu mai aduc valoare sau dublează alte niveluri de testare.
  • Introduci reguli de prevenție: un test nou trebuie să treacă de mai multe ori (--repeat-each) înainte de merge; testele flaky raportate automat.
  • Stabilești o limită de timp pentru carantină: un test care nu e reparat într-un interval convenit e șters sau rescris.

Comunicare. Arăți echipei o listă scurtă, săptămânală: câte teste în carantină, câte reparate. Implici developerii când cauza e în aplicație.

Rezultatul urmărit: pipeline-ul roșu e din nou un semnal pe care echipa îl ia în serios.

Ce urmărește intervievatorul: Întrebare comportamentală de senior. Se urmărește dacă reconstruiești încrederea sistematic. Răspunsul slab este „dezactivez testele care pică”.

Selenium WebDriver

Exersează capitolul cu exerciții reale: Curs testare automată →
83 Junior

Explică arhitectura Selenium WebDriver: ce se întâmplă când scrii await driver.findElement(By.id('email'))?

Răspuns scurt: Biblioteca client transformă apelul într-o cerere HTTP conform protocolului W3C WebDriver, trimisă driverului specific browserului (chromedriver, geckodriver), care controlează browserul și întoarce răspunsul JSON. Fiecare comandă e un drum dus-întors prin acest lanț.

Componentele:

  • Biblioteca client (selenium-webdriver pentru JavaScript, echivalente în Java, Python, C#): API-ul pe care îl scrii.
  • Protocolul W3C WebDriver: standard care definește comenzile ca endpoint-uri HTTP REST cu JSON. De exemplu, căutarea unui element e un POST /session/{id}/element.
  • Driverul browserului: chromedriver, geckodriver, msedgedriver, safaridriver. Un executabil separat care primește comenzile și controlează browserul prin mecanismele lui interne.
  • Browserul.
JavaScript
const { Builder, By } = require('selenium-webdriver');

(async () => {
  const driver = await new Builder().forBrowser('chrome').build(); // pornește sesiunea
  try {
    await driver.get('https://shoprapid.test/login');
    const email = await driver.findElement(By.id('email'));         // o cerere HTTP
    await email.sendKeys('ana@test.ro');                             // altă cerere
  } finally {
    await driver.quit();                                             // închide sesiunea
  }
})();

Din Selenium 4.6, Selenium Manager descarcă automat driverul potrivit versiunii de browser, deci nu mai e nevoie să gestionezi manual chromedriver.

Consecințe practice:

  • fiecare comandă e o cerere separată, iar Selenium nu așteaptă implicit ca elementul să fie gata; sincronizarea e responsabilitatea ta (așteptări explicite);
  • fiind un standard, aceleași teste rulează pe toate browserele care au driver, și pe Selenium Grid, la distanță;
  • driver.quit() trebuie apelat mereu (de obicei în finally sau în hook-ul after), altfel rămân procese de browser deschise.

Selenium 4 adaugă treptat suport pentru WebDriver BiDi, un protocol bidirecțional peste WebSocket, care permite evenimente (loguri, rețea) fără polling.

Ce urmărește intervievatorul: Întrebare de bază pentru orice interviu Selenium. Se verifică dacă știi rolul driverului și al protocolului, nu doar API-ul.

84 Junior

Care e diferența dintre findElement și findElements în Selenium? Ce se întâmplă când elementul nu există?

Răspuns scurt: findElement întoarce primul element găsit și aruncă NoSuchElementError dacă nu găsește niciunul. findElements întoarce un tablou, gol dacă nu există potriviri, fără eroare. Ambele respectă implicit wait-ul, dacă e setat.

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

// un element: primul care se potrivește
const titlu = await driver.findElement(By.css('h1'));

// mai multe: tablou, eventual gol
const carduri = await driver.findElements(By.css('[data-testid="product-card"]'));
console.log(carduri.length);

// verificarea absenței fără excepție
const erori = await driver.findElements(By.css('.error'));
assert.strictEqual(erori.length, 0);

// tratarea explicită a lipsei
try {
  await driver.findElement(By.id('promo'));
} catch (e) {
  if (!(e instanceof error.NoSuchElementError)) throw e;
}

Strategiile By: By.id, By.name, By.css, By.xpath, By.className, By.linkText, By.partialLinkText, By.tagName, plus By.js. Cele mai folosite sunt By.css (inclusiv pentru data-testid) și By.xpath pentru căutări după text.

Diferențe importante față de Playwright:

  • findElement nu este strict: dacă sunt trei butoane, întoarce primul, fără avertisment. Ambiguitatea trece neobservată.
  • Rezultatul e o referință la nodul DOM de atunci. Dacă pagina re-randează elementul, referința devine invalidă (StaleElementReferenceError).
  • Fără implicit wait, findElement caută o singură dată. Cu implicit wait setat, findElements așteaptă tot intervalul înainte să întoarcă tabloul gol, deci verificarea absenței devine lentă.

Căutarea se poate face și relativ la un element: await card.findElement(By.css('button')) caută doar în interiorul cardului, echivalentul înlănțuirii locatorilor din Playwright.

Ce urmărește intervievatorul: Se verifică bazele API-ului Selenium și înțelegerea diferenței de comportament la lipsa elementului.

Eroarea, în practică:NoSuchElementError: no such element

85 Junior

Scrie scheletul unui test Selenium cu Mocha pentru login: pornirea browserului, testul și închiderea. Ce capcane are timeout-ul Mocha?

Răspuns scurt: Pornești driverul în before, îl închizi în after cu quit(), scrii testul în it cu așteptări explicite și assert. Mocha are timeout implicit de 2 secunde per test, prea mic pentru un browser, iar this.timeout() merge doar în funcții normale, nu în arrow functions.

JavaScript
const { Builder, By, until } = require('selenium-webdriver');
const assert = require('node:assert/strict');

describe('Login', function () {
  this.timeout(30_000);         // Mocha: implicit 2000 ms
  let driver;

  before(async function () {
    driver = await new Builder().forBrowser('chrome').build();
  });

  after(async function () {
    if (driver) await driver.quit();
  });

  beforeEach(async function () {
    await driver.manage().deleteAllCookies();
    await driver.get('https://shoprapid.test/login');
  });

  it('login valid duce în cont', async function () {
    await driver.findElement(By.id('email')).sendKeys('ana@test.ro');
    await driver.findElement(By.id('password')).sendKeys(process.env.TEST_PASSWORD);
    await driver.findElement(By.css('button[type="submit"]')).click();

    await driver.wait(until.urlContains('/cont'), 5_000);
    const salut = await driver.wait(until.elementLocated(By.css('[data-testid="greeting"]')), 5_000);
    assert.equal(await salut.getText(), 'Bună, Ana!');
  });
});

Capcane:

  • Timeout-ul Mocha de 2 secunde: pornirea browserului singură îl poate depăși. Îl setezi în describe cu this.timeout() sau global, în .mocharc (timeout: 30000).
  • Arrow functions: în describe(() => { this.timeout(...) }), this nu e contextul Mocha, deci apelul eșuează. De aceea exemplul folosește function.
  • Browser comun: aici un browser pentru toate testele din fișier (pentru viteză), cu cookie-urile curățate în beforeEach. localStorage rămâne însă; pentru izolare completă pornești driverul în beforeEach, mai lent.
  • quit vs close: close() închide fereastra curentă, quit() închide sesiunea și driverul.

Ce urmărește intervievatorul: Exercițiu practic de setup. Se urmărește gestionarea ciclului de viață al driverului și cunoașterea capcanelor Mocha.

Eroarea, în practică:NoSuchSessionError: invalid session idMocha: Timeout of 2000ms exceeded

86 Junior

Cum rulezi Chrome headless în Selenium cu JavaScript și ce alte opțiuni de browser setezi de obicei pe CI?

Răspuns scurt: Creezi un chrome.Options(), adaugi argumentul --headless=new și dimensiunea ferestrei, apoi îl dai builder-ului cu setChromeOptions. Pe CI mai setezi limba, fusul orar sau dezactivarea unor funcții care îți încurcă testele.

JavaScript
const { Builder } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

function buildDriver() {
  const options = new chrome.Options();
  if (process.env.CI) options.addArguments('--headless=new');
  options.addArguments(
    '--window-size=1366,900',
    '--lang=ro-RO',
    '--disable-search-engine-choice-screen'
  );
  options.setUserPreferences({ 'intl.accept_languages': 'ro-RO' });

  return new Builder()
    .forBrowser('chrome')
    .setChromeOptions(options)
    .build();
}

Explicații:

  • --headless=new folosește modul headless nou al Chrome (disponibil din Chrome 109), mult mai apropiat de browserul obișnuit decât vechiul headless. În versiunile recente de Chrome, vechiul mod a fost separat într-un binar distinct, deci --headless=new este forma recomandată.
  • Dimensiunea ferestrei: în headless, fereastra implicită poate fi mică, iar layout-ul responsive ascunde meniuri sau butoane, ceea ce produce eșecuri doar pe CI.
  • Limba: afectează textele și formatarea; o fixezi ca testele să nu depindă de mașină.
  • Pe Linux în containere apar uneori --no-sandbox și --disable-dev-shm-usage. Primul reduce izolarea de securitate a browserului, deci se folosește doar în containere de test controlate, nu din reflex.

Pentru Firefox: require('selenium-webdriver/firefox'), new firefox.Options().addArguments('-headless') și setFirefoxOptions.

Headless nu e identic cu headed în toate privințele (fonturi, GPU, unele API-uri), de aceea, când un test pică doar headless, îl rulezi o dată headed cu aceleași dimensiuni pentru comparație.

Ce urmărește intervievatorul: Verifică dacă ai rulat Selenium pe CI. Greșeala tipică este lipsa dimensiunii ferestrei și testele care pică doar headless.

87 Junior

Cum faci în Selenium (JavaScript) hover pe un meniu, tastarea Enter și acceptarea unui confirm() al browserului?

Răspuns scurt: Hover-ul se face cu Actions API (driver.actions().move({ origin: el })), tastele cu sendKeys și constantele Key, iar dialogul nativ cu driver.wait(until.alertIsPresent()) urmat de switchTo().alert().accept().

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

// hover: meniul utilizatorului apare la trecerea mouse-ului
const meniu = await driver.findElement(By.css('[data-testid="user-menu"]'));
await driver.actions({ async: true }).move({ origin: meniu }).perform();
const logout = await driver.wait(
  until.elementIsVisible(driver.findElement(By.linkText('Deconectare'))),
  3_000
);

// taste: căutare cu Enter
const cautare = await driver.findElement(By.name('q'));
await cautare.sendKeys('tricou', Key.ENTER);

// combinații: select all + delete
await cautare.sendKeys(Key.chord(Key.CONTROL, 'a'), Key.BACK_SPACE);

// dialog nativ confirm()
await driver.findElement(By.css('[data-testid="delete-account"]')).click();
await driver.wait(until.alertIsPresent(), 3_000);
const alerta = await driver.switchTo().alert();
console.log(await alerta.getText());
await alerta.accept();        // sau dismiss()

Observații:

  • Actions API construiește o secvență de acțiuni de nivel jos (mișcare, apăsare, eliberare, scroll, drag and drop) executată cu perform(). Pentru drag and drop există dragAndDrop(sursa, tinta).
  • Key.CONTROL pe macOS ar trebui să fie Key.COMMAND; testele cross-platform evită combinațiile dependente de sistem sau le aleg în funcție de process.platform.
  • Dialogurile native blochează pagina: cât timp alerta e deschisă, alte comenzi eșuează cu UnexpectedAlertOpenError. În Playwright, comparativ, dialogurile sunt închise automat dacă nu ai handler, iar tu le tratezi prin page.on('dialog').
  • elementIsVisible primește un element deja găsit; dacă elementul apare mai târziu în DOM, folosești întâi until.elementLocated.

Ce urmărește intervievatorul: Verifică cunoașterea API-ului de interacțiuni din Selenium. Mulți nu știu cum se tratează alertele native.

Eroarea, în practică:NoSuchAlertError: no such alertUnexpectedAlertOpenError: unexpected alert open

88 Mid

Ce se întâmplă dacă setezi un implicit wait de 10 secunde și folosești și driver.wait(until.elementLocated(...), 5000)? De ce documentația Selenium spune să nu le amesteci?

Răspuns scurt: Rezultatul devine imprevizibil: fiecare căutare internă a așteptării explicite poate bloca până la 10 secunde din cauza celei implicite, deci explicitul de 5 secunde poate dura mult mai mult. Plus, verificările de absență devin lente. Se alege un singur mecanism, de regulă așteptările explicite.

Implicit wait (await driver.manage().setTimeouts({ implicit: 10_000 })) se aplică la nivelul driverului fiecărei căutări de element: dacă elementul nu există, driverul reîncearcă până la 10 secunde înainte să răspundă cu „not found”.

Explicit wait (driver.wait(condiție, timeout)) e o buclă în client: evaluează condiția repetat până devine adevărată sau expiră timpul.

Când le combini, fiecare evaluare a condiției explicite face o căutare de element, iar căutarea așteaptă ea însăși până la 10 secunde în driver. Bucla de 5 secunde nu poate întrerupe o căutare deja pornită, deci eșecul apare după un timp mai mare decât cel declarat, iar durata reală depinde de implementarea driverului. Documentația Selenium avertizează explicit că amestecul produce timpi de așteptare imprevizibili.

Alte efecte ale implicit wait-ului:

  • findElements pentru verificarea absenței așteaptă tot intervalul înainte să întoarcă tabloul gol;
  • condițiile de tip „elementul a dispărut” devin lente sau greu de exprimat;
  • așteaptă doar existența în DOM, nu vizibilitatea sau posibilitatea de click.

Practica recomandată: implicit wait 0, așteptări explicite pe condiția relevantă, ascunse în metodele Page Object-urilor:

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

async function clickWhenReady(driver, locator, timeout = 5_000) {
  const el = await driver.wait(until.elementLocated(locator), timeout);
  await driver.wait(until.elementIsVisible(el), timeout);
  await driver.wait(until.elementIsEnabled(el), timeout);
  await el.click();
}

Este, în esență, ce face auto-waiting-ul din Playwright în mod implicit.

Ce urmărește intervievatorul: Detaliu care separă nivelul mid. Se verifică dacă înțelegi unde rulează fiecare tip de așteptare, nu doar că există două.

Eroarea, în practică:NoSuchElementError: no such elementdriver.manage(...).timeouts is not a function

89 Mid

Cum arată un Page Object bun în Selenium cu JavaScript și prin ce diferă de unul Playwright?

Răspuns scurt: Ține locatorii ca obiecte By, nu ca elemente găsite, și caută elementul în momentul acțiunii, cu așteptări explicite incluse în metode. Diferența față de Playwright: sincronizarea și protecția împotriva elementelor învechite sunt scrise de tine, nu oferite de unealtă.

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

class LoginPage {
  constructor(driver) {
    this.driver = driver;
    this.email = By.id('email');
    this.password = By.id('password');
    this.submit = By.css('button[type="submit"]');
    this.error = By.css('[role="alert"]');
  }

  async open() {
    await this.driver.get(`${process.env.BASE_URL}/login`);
    await this.driver.wait(until.elementLocated(this.email), 5_000);
  }

  async type(locator, text) {
    const el = await this.driver.wait(until.elementLocated(locator), 5_000);
    await this.driver.wait(until.elementIsEnabled(el), 5_000);
    await el.clear();
    await el.sendKeys(text);
  }

  async loginAs(email, password) {
    await this.type(this.email, email);
    await this.type(this.password, password);
    await this.driver.findElement(this.submit).click();
  }

  async errorText() {
    const el = await this.driver.wait(until.elementLocated(this.error), 5_000);
    await this.driver.wait(until.elementIsVisible(el), 5_000);
    return el.getText();
  }
}
module.exports = { LoginPage };

Principii:

  • Locatori By în constructor, nu WebElement. Un element găsit în constructor devine învechit după prima re-randare și produce StaleElementReferenceError.
  • Așteptările în metode: testul nu trebuie să știe de sincronizare.
  • Metodele care citesc valori (errorText) întorc date, iar aserțiunile rămân în test.

Diferențe față de Playwright:

  • în Playwright locatorii sunt deja lazy și au auto-waiting, deci metoda type de mai sus se reduce la await this.email.fill(text);
  • aserțiunile web-first nu există în Selenium cu assert; verificarea unei valori care se schimbă cere driver.wait cu o condiție proprie;
  • în Selenium nu există strict mode, deci locatorii trebuie gândiți să fie unici.

Java are PageFactory cu @FindBy; în JavaScript nu există echivalent oficial, iar tiparul de mai sus e cel uzual.

Ce urmărește intervievatorul: Se verifică dacă știi să scrii Page Objects robuste fără ajutorul unui framework. Greșeala tipică este căutarea elementelor în constructor.

Eroarea, în practică:StaleElementReferenceError: stale element

90 Mid

Ce este Selenium Grid și cum rulezi testele pe el?

Răspuns scurt: Selenium Grid distribuie sesiunile WebDriver pe mai multe mașini sau containere cu browsere diferite. Testele se conectează la adresa Grid-ului cu usingServer() și cer browserul dorit prin capabilități, iar Grid-ul alege un nod liber potrivit.

Grid-ul rezolvă două probleme: rularea în paralel pe mai multe mașini și rularea pe combinații de browsere și sisteme de operare pe care nu le ai local.

În Selenium Grid 4, componentele sunt Router, Distributor, Session Map, New Session Queue, Event Bus și Nodes. Ele pot rula:

  • standalone: totul într-un singur proces, util local sau în CI;
  • hub și noduri: hub-ul grupează componentele centrale, nodurile au browserele;
  • distribuit: fiecare componentă separat, pentru infrastructuri mari.

Pornire rapidă cu Docker (imaginile oficiale selenium/standalone-chrome, selenium/hub, selenium/node-chrome):

BASH
docker run -d -p 4444:4444 --shm-size=2g selenium/standalone-chrome

Conectarea testelor:

JavaScript
const { Builder } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

const driver = await new Builder()
  .usingServer('http://localhost:4444')
  .forBrowser('chrome')
  .setChromeOptions(new chrome.Options().addArguments('--window-size=1366,900'))
  .build();

Grid-ul primește cererea de sesiune nouă cu capabilitățile (browser, versiune, platformă), o pune în coadă și o atribuie unui nod liber. Interfața web de la portul 4444 arată nodurile, sesiunile active și coada.

Aspecte de spus la interviu:

  • paralelismul ține de runner (Mocha cu --parallel sau mai multe procese); Grid-ul doar oferă browsere;
  • fișierele (upload) trebuie trimise nodului: driver.setFileDetector(new remote.FileDetector());
  • serviciile cloud (BrowserStack, Sauce Labs, LambdaTest) oferă un Grid compatibil, cu mai multe browsere și dispozitive reale.

Playwright nu are un echivalent Grid oficial; scalarea se face prin workeri și sharding pe mai multe mașini CI.

Ce urmărește intervievatorul: Verifică dacă știi cum se scalează Selenium în proiecte reale. Mulți confundă Grid-ul cu paralelismul runner-ului.

91 Senior

Compară arhitectural Playwright și Selenium: cum comunică fiecare cu browserul și ce consecințe practice are?

Răspuns scurt: Selenium trimite fiecare comandă ca cerere HTTP prin protocolul standard W3C WebDriver către un driver separat. Playwright folosește o conexiune persistentă (WebSocket sau pipe) cu un server propriu care controlează browserele prin protocoale interne. De aici diferențele de viteză și de evenimente.

Selenium WebDriver

  • Client → HTTP (W3C WebDriver) → driverul browserului → browser.
  • Fiecare comandă e o cerere separată, sincronă din punctul de vedere al protocolului. Browserul nu poate „împinge” evenimente spre test, deci loguri, cereri de rețea sau dialoguri se află prin interogare.
  • Avantaj major: este un standard implementat de producătorii de browsere. Rulează pe browserele reale de branduri (Chrome, Edge, Firefox, Safari prin safaridriver), pe Grid și pe furnizori cloud, din multe limbaje.
  • WebDriver BiDi, standardul în curs de adoptare, adaugă o conexiune WebSocket bidirecțională pentru evenimente și interceptarea rețelei, apropiind capabilitățile de cele ale Playwright.

Playwright

  • Client (Node, Python, Java, .NET) → conexiune persistentă → serverul Playwright → browser. Pentru Chromium folosește Chrome DevTools Protocol, pentru Firefox și WebKit versiuni modificate ale browserelor, livrate de Playwright și fixate pe versiunea bibliotecii.
  • Conexiunea e bidirecțională: evenimentele (cereri, răspunsuri, dialoguri, consolă) vin instant, ceea ce face posibile page.route, waitForResponse, trace-urile și auto-waiting-ul implementat în partea de browser.
  • Contextele de browser izolate fac izolarea per test foarte ieftină.
  • Dezavantaj: WebKit din Playwright nu e Safari; testezi motorul, nu produsul Apple. Versiunile de browser sunt cele livrate cu Playwright, deși poți folosi Chrome sau Edge instalat prin channel.

Consecințe la alegerea uneltei

  • aplicație nouă, echipă JavaScript sau TypeScript, nevoie de mock-uri de rețea și depanare bună → de obicei Playwright;
  • suită existentă mare, limbaje diverse, nevoie de Safari real sau de o infrastructură Grid existentă → Selenium rămâne justificat.

Ce urmărește intervievatorul: Întrebare de senior care cere înțelegerea mecanismelor, nu o listă de funcții. Răspunsul slab este „Playwright e mai nou și mai rapid”.

92 Senior

Compania vrea să migreze o suită Selenium de câteva sute de teste la Playwright. Cum planifici migrarea?

Răspuns scurt: Validezi întâi motivul și beneficiul cu un pilot pe câteva fluxuri, apoi migrezi incremental, pe module, cu ambele suite rulând în paralel o perioadă. Nu traduci linie cu linie: refaci testele pe tiparele Playwright (locatori, fixtures, aserțiuni web-first) și elimini ce nu mai aduce valoare.

Model de răspuns pe etape:

1. Motivul și criteriile de succes. De ce migrăm: instabilitate, durată, cost de întreținere, nevoia de mock-uri de rețea? Aduni date din suita actuală (teste instabile, durată, timp de reparare), ca să poți arăta ulterior dacă migrarea a adus ce s-a promis.

2. Pilot. Migrezi câteva fluxuri reprezentative, inclusiv unul dificil (iframe de plată, upload, autentificare). Compari stabilitatea și durata. Identifici blocajele: un browser necesar care nu e acoperit, integrarea cu un Grid sau cu un raport existent.

3. Fundația. Config, structură de proiect, fixtures pentru autentificare (storageState) și date, Page Objects noi, rulare în CI, raportare. Convențiile se stabilesc acum, nu după sute de teste.

4. Migrare incrementală, pe module. Pentru fiecare modul:

  • revizuiești cazurile: unele se șterg, unele coboară la nivel de API;
  • rescrii pe tiparele Playwright, nu traduci: driver.wait(until...) dispare, căutările XPath devin locatori pe rol;
  • rulezi ambele variante o perioadă, apoi oprești testele Selenium pentru modulul migrat.

5. Oameni. Training scurt pentru echipă, pairing pe primele PR-uri, code review atent pe tiparele noi.

Riscuri de menționat: perioada cu două suite costă dublu; migrarea „1:1” mută și problemele vechi; cerințele de Safari real pot impune păstrarea unei părți din Selenium sau un furnizor cloud.

Rezultatul raportat: modulele migrate, comparația de stabilitate și durată față de punctul de plecare.

Ce urmărește intervievatorul: Întrebare de situație pentru senior. Se urmărește planul incremental, măsurabil, și refuzul traducerii mecanice.

Paralelizare, CI și raportare

93 Junior

Scrie un workflow GitHub Actions care rulează testele Playwright la fiecare pull request și păstrează raportul.

Răspuns scurt: Workflow-ul face checkout, instalează Node și dependențele cu npm ci, instalează browserele cu npx playwright install --with-deps, rulează testele și încarcă raportul HTML ca artefact chiar dacă testele au picat.

YAML
name: Teste E2E
on:
  pull_request:
  push:
    branches: [main]

jobs:
  e2e:
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test
        env:
          BASE_URL: ${{ vars.STAGING_URL }}
          TEST_PASSWORD: ${{ secrets.TEST_PASSWORD }}
      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: playwright-report
          path: playwright-report/
          retention-days: 14

Explicații:

  • npm ci instalează exact versiunile din package-lock.json, deci aceeași versiune de Playwright ca local.
  • npx playwright install --with-deps descarcă browserele potrivite versiunii instalate și dependențele de sistem pentru Linux. Ca optimizare, poți instala doar ce folosești: npx playwright install --with-deps chromium.
  • Variabila CI e setată automat de GitHub Actions, deci configul aplică singur forbidOnly, retries și numărul de workeri pentru CI.
  • Secretele (secrets.*) nu apar în loguri și nu ajung în cod; variabilele nesensibile pot sta în vars.*.
  • if: ${{ !cancelled() }} încarcă raportul și când pasul de teste a picat, exact când ai cea mai mare nevoie de el.
  • timeout-minutes oprește un job blocat, în loc să consume minutele de CI.

Pentru a vedea eșecurile direct în PR, poți adăuga reporterul github, care produce adnotări pe liniile cu probleme.

Ce urmărește intervievatorul: Exercițiu practic frecvent. Se urmărește încărcarea artefactelor la eșec și gestionarea secretelor. Greșeala tipică este artefactul încărcat doar la succes.

Eroarea, în practică:browserType.launch: Executable doesn't exist

94 Junior

Cum paralelizează Playwright testele implicit? Ce schimbă fullyParallel și opțiunea workers?

Răspuns scurt: Implicit, fișierele de test rulează în paralel, în procese separate numite workeri (implicit jumătate din nucleele logice), iar testele din același fișier rulează în ordine, în același worker. fullyParallel: true distribuie și testele din același fișier, iar workers stabilește numărul de procese.

Modelul:

  • Worker = un proces Node separat, cu propriul browser. Workerii nu împart memorie, deci variabilele globale din teste nu sunt comune.
  • Implicit, numărul de workeri este jumătate din nucleele logice ale mașinii.
  • Implicit, fișierele sunt distribuite între workeri, iar testele unui fișier rulează secvențial, în ordinea declarării, în același worker.

Opțiuni:

JavaScript
export default defineConfig({
  fullyParallel: true,                     // și testele din același fișier, în paralel
  workers: process.env.CI ? 2 : undefined, // sau un procent: '50%'
});
BASH
npx playwright test --workers=4
npx playwright test --workers=1     # util la depanare

La nivel de fișier: test.describe.configure({ mode: 'parallel' }) sau mode: 'serial'.

Ce trebuie să știi pentru teste stabile în paralel:

  • testele trebuie să fie independente, inclusiv în datele din backend;
  • testInfo.workerIndex (sau parallelIndex) ajută la date unice per worker, de exemplu câte un cont de test;
  • beforeAll rulează o dată per worker, nu o dată per rulare;
  • la eșecul unui test, workerul e repornit, iar testele rămase merg într-unul nou.

Mai mulți workeri nu înseamnă automat o suită mai rapidă: pe un runner CI cu puține nuclee, prea mulți workeri fac browserele să concureze pe CPU și produc timeout-uri. Pentru scalare dincolo de o mașină se folosește sharding.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de execuție. Mulți cred că testele dintr-un fișier rulează implicit în paralel.

95 Junior

Ce reporteri are Playwright și cum configurezi mai mulți deodată, de exemplu HTML pentru oameni și JUnit pentru CI?

Răspuns scurt: Reporterii încorporați sunt list, line, dot, html, json, junit, github și blob. În config dai un tablou, cu opțiuni pentru fiecare, iar toți primesc aceleași rezultate.

Reporterii decid cum sunt prezentate rezultatele:

  • list: câte o linie per test, implicit local;
  • dot: un caracter per test, compact, implicit pe CI;
  • line: o singură linie actualizată, plus erorile;
  • html: raport interactiv cu filtre, pași, atașamente, trace-uri; se deschide cu npx playwright show-report;
  • json: toate rezultatele într-un fișier, pentru procesare proprie;
  • junit: XML în format JUnit, citit de Jenkins, GitLab, Azure DevOps și de multe dashboard-uri;
  • github: adnotări în GitHub Actions, pe liniile testelor picate;
  • blob: format intern, pentru unirea rapoartelor din mai multe sharduri.

Configurare:

JavaScript
export default defineConfig({
  reporter: process.env.CI
    ? [
        ['dot'],
        ['github'],
        ['junit', { outputFile: 'results/junit.xml' }],
        ['html', { open: 'never', outputFolder: 'playwright-report' }],
      ]
    : [['list'], ['html', { open: 'on-failure' }]],
});

Din linia de comandă: npx playwright test --reporter=line.

Pentru nevoi speciale poți scrie un reporter propriu, o clasă cu metodele onBegin, onTestEnd, onEnd, de exemplu pentru a trimite un rezumat într-un canal de chat. Există și reporteri de comunitate, precum allure-playwright, pentru istoric între rulări.

Pe CI e important ca raportul HTML să fie încărcat ca artefact și ca open: 'never' să fie setat, altfel reporterul poate încerca să deschidă un server la finalul rulării.

Ce urmărește intervievatorul: Verifică dacă știi să integrezi rezultatele în fluxul echipei. Greșeala tipică este un singur reporter, potrivit fie pentru oameni, fie pentru CI, dar nu pentru amândoi.

96 Junior

Ce setezi diferit în config când testele rulează în CI față de local și de ce?

Răspuns scurt: În CI interzici test.only (forbidOnly), activezi retry-urile și artefactele la eșec, fixezi numărul de workeri pentru resursele runner-ului, alegi reporteri pentru mașini și nu refolosești un server pornit. Local vrei feedback rapid și eșecuri vizibile, fără retry.

Configul folosește variabila CI, setată automat de majoritatea platformelor de CI:

JavaScript
const isCI = !!process.env.CI;

export default defineConfig({
  forbidOnly: isCI,
  retries: isCI ? 2 : 0,
  workers: isCI ? 2 : undefined,
  reporter: isCI ? [['dot'], ['html', { open: 'never' }]] : 'list',
  use: {
    baseURL: process.env.BASE_URL ?? 'http://localhost:3000',
    trace: isCI ? 'on-first-retry' : 'retain-on-failure',
    locale: 'ro-RO',
    timezoneId: 'Europe/Bucharest',
  },
  webServer: {
    command: 'npm run start',
    url: 'http://localhost:3000',
    reuseExistingServer: !isCI,
  },
});

De ce fiecare:

  • forbidOnly: un test.only uitat ar face CI-ul să ruleze un singur test și să raporteze verde. Cu opțiunea activă, rularea pică imediat.
  • retries: pe CI acceptă instabilități rare de infrastructură (cu raportarea testelor flaky); local vrei să vezi problema imediat.
  • workers: runner-ele CI au de obicei puține nuclee; prea mulți workeri duc la timeout-uri.
  • Reporteri: compacți pentru loguri, HTML ca artefact.
  • reuseExistingServer: local refolosești serverul pornit de tine; pe CI e pornit curat de Playwright.
  • locale și timezoneId fixe: aceleași rezultate indiferent de setările mașinii.
  • baseURL din variabilă de mediu: aceeași suită rulează pe local, preview sau staging.

Principiul: diferențele dintre medii sunt explicite și puține. Cu cât CI-ul diferă mai mult de local, cu atât apar mai des teste care „merg doar la mine”.

Ce urmărește intervievatorul: Verifică dacă înțelegi motivele din spatele configurației generate, nu doar că ai copiat-o.

Eroarea, în practică:item focused with '.only' is not allowed

97 Mid

Cum împarți suita pe mai multe mașini CI cu sharding și cum obții un singur raport la final?

Răspuns scurt: Rulezi aceeași suită pe N joburi cu --shard=i/N, fiecare cu reporterul blob, încarci rezultatele ca artefacte, apoi un job final le descarcă și le unește cu npx playwright merge-reports --reporter html.

Sharding-ul împarte testele în N grupuri aproximativ egale; fiecare mașină rulează un grup. Se combină cu workerii: fiecare shard își paralelizează la rândul lui testele local.

YAML
jobs:
  e2e:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, cache: npm }
      - run: npm ci
      - run: npx playwright install --with-deps chromium
      - run: npx playwright test --shard=${{ matrix.shard }} --reporter=blob
      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: blob-${{ strategy.job-index }}
          path: blob-report/

  raport:
    if: ${{ !cancelled() }}
    needs: e2e
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, cache: npm }
      - run: npm ci
      - uses: actions/download-artifact@v4
        with:
          path: all-blob-reports
          pattern: blob-*
          merge-multiple: true
      - run: npx playwright merge-reports --reporter html ./all-blob-reports
      - uses: actions/upload-artifact@v4
        with: { name: playwright-report, path: playwright-report/ }

Detalii:

  • fail-fast: false: un shard picat nu le oprește pe celelalte, ca să ai rezultatele complete.
  • Cu fullyParallel: true, împărțirea se face la nivel de test, deci shardurile sunt mai echilibrate; altfel la nivel de fișier, iar un fișier mare poate face un shard mult mai lent.
  • Raportul unit conține trace-urile și atașamentele din toate shardurile.

Cost: fiecare shard repetă instalarea și pornirea, deci câștigul apare la suite suficient de mari. Cache-ul pentru node_modules și browsere reduce acest cost.

Ce urmărește intervievatorul: Întrebare de mid despre scalarea suitei. Se verifică dacă știi și partea de unire a rapoartelor, adesea uitată.

98 Mid

Testele trebuie să ruleze împotriva aplicației pornite în CI. Cum folosești webServer și cum rulezi aceeași suită pe un mediu de preview sau de staging?

Răspuns scurt: webServer în config pornește aplicația înainte de teste, așteaptă până răspunde URL-ul dat și o oprește la final. Pentru alt mediu, nu pornești serverul și setezi baseURL din variabila de mediu, iar testele folosesc doar căi relative.

Configurare:

JavaScript
const baseURL = process.env.BASE_URL ?? 'http://localhost:3000';
const local = !process.env.BASE_URL;

export default defineConfig({
  use: { baseURL },
  webServer: local
    ? {
        command: 'npm run build && npm run start',
        url: 'http://localhost:3000/health',
        timeout: 120_000,
        reuseExistingServer: !process.env.CI,
        stdout: 'ignore',
        stderr: 'pipe',
      }
    : undefined,
});

Cum funcționează:

  • Playwright rulează comanda, apoi verifică periodic url până primește un răspuns de succes sau expiră timeout. Abia apoi pornesc testele.
  • reuseExistingServer local evită pornirea a doua oară dacă serverul tău de dezvoltare rulează deja.
  • La final, procesul pornit e oprit automat.
  • Se pot porni mai multe servere (frontend și un API simulat) dând un tablou de configurații.

Un endpoint de sănătate (/health) e mai bun decât pagina principală pentru verificare: răspunde doar când aplicația e gata, inclusiv conexiunea la baza de date.

Rularea pe un mediu de preview creat per pull request (Vercel, Netlify sau un mediu propriu): jobul de CI primește adresa, o setează în BASE_URL, iar suita rulează fără webServer. Condiția este ca testele să nu conțină URL-uri absolute, ci doar page.goto('/cos').

Atenție la date: pe un mediu partajat de staging, testele trebuie să-și creeze singure datele și să le curețe, pentru că și alți oameni sau alte pipeline-uri folosesc același mediu.

Ce urmărește intervievatorul: Verifică dacă poți integra suita în fluxuri reale de livrare. Greșeala tipică sunt URL-urile hardcodate în teste, care leagă suita de un singur mediu.

Eroarea, în practică:page.goto: net::ERR_CONNECTION_REFUSED

99 Senior

Proiectează rularea testelor automate în pipeline-ul unei echipe care face mai multe deploy-uri pe zi. Ce rulează, când și ce blochează?

Răspuns scurt: Pe straturi: la fiecare PR, teste unitare, de API și un smoke E2E rapid, care blochează merge-ul; după merge, suita E2E completă pe un browser, pe staging; nightly, cross-browser, vizual și testele lente; după deploy, un smoke pe producție, doar cu operații sigure.

Principiul: cel mai rapid feedback pentru cele mai importante riscuri, iar testele lente mai rar, fără să blocheze munca.

La fiecare pull request (blochează merge-ul)

  • lint pentru teste și cod, teste unitare și de componentă;
  • teste API pe endpoint-urile modificate sau pe toată suita, dacă e rapidă;
  • E2E @smoke pe Chromium, pe un mediu de preview sau cu webServer, cu sharding dacă e nevoie.

După merge în ramura principală (blochează deploy-ul în producție)

  • suita E2E completă pe un browser, pe staging, cu date create de teste;
  • raport publicat și notificare la eșec către autorul ultimului merge.

Nightly sau programat (nu blochează, dar are responsabil)

  • toate proiectele: Firefox, WebKit, mobil emulat;
  • testele vizuale, de accesibilitate automată, testele care ating servicii externe în sandbox;
  • testele din carantină, ca să vezi dacă s-au stabilizat.

După deploy în producție

  • un smoke foarte scurt, doar cu operații care nu modifică date reale sau cu conturi de test dedicate, fără plăți reale; dacă pică, declanșează rollback-ul sau alerta.

Decizii de spus explicit la interviu:

  • ce blochează e mic și stabil; un test instabil nu are loc în etapa care blochează;
  • timpul țintă pentru etapa de PR se stabilește cu echipa, pentru că un pipeline lent e ocolit;
  • fiecare etapă are un proprietar pentru eșecuri;
  • testele se pot selecta după fișierele modificate, dar cu prudență, pentru că dependențele indirecte sunt greu de urmărit.

Ce urmărește intervievatorul: Întrebare de senior despre strategie de livrare. Se urmărește echilibrul dintre viteză și acoperire și cine reacționează la eșecuri.

100 Senior

De ce ai rula testele Playwright în containerul Docker oficial, chiar dacă pe runner-ul de CI merg și fără el?

Răspuns scurt: Pentru un mediu identic peste tot: același sistem de operare, aceleași fonturi, aceleași dependențe și aceeași versiune de browser, local și pe CI. Asta contează mai ales la testele vizuale, unde fonturile diferite produc diferențe de pixeli, și la reproducerea eșecurilor de pe CI.

Imaginile oficiale (mcr.microsoft.com/playwright) conțin Node, browserele pentru o versiune anume de Playwright și toate dependențele de sistem. Eticheta imaginii trebuie să corespundă versiunii din package.json, altfel browserele nu se potrivesc cu biblioteca.

YAML
jobs:
  e2e:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/playwright:v1.49.1-noble
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20 }
      - run: npm ci
      - run: npx playwright test
        env:
          HOME: /root

Local, aceeași imagine:

BASH
docker run --rm -it -v "$PWD":/work -w /work --ipc=host \
  mcr.microsoft.com/playwright:v1.49.1-noble \
  npx playwright test --update-snapshots

Beneficii:

  • Testele vizuale: referințele se generează și se compară în același mediu; fără container, o captură făcută pe macOS nu se potrivește cu cea de pe Linux.
  • Reproducerea: un eșec de pe CI se reproduce local în același mediu, eliminând o întreagă categorie de diferențe.
  • Viteza de instalare: browserele sunt deja în imagine, nu se mai descarcă la fiecare rulare.
  • Versiuni fixate: imaginea e legată de versiunea Playwright, deci actualizarea e explicită, printr-un PR.

Detalii de spus: --ipc=host e recomandat pentru Chromium, altfel memoria partajată mică din container poate face browserul să se blocheze; HOME=/root evită probleme ale Firefox cu permisiunile pe GitHub Actions. La actualizarea Playwright, actualizezi și eticheta imaginii, apoi regenerezi referințele vizuale în container.

Ce urmărește intervievatorul: Întrebare de senior despre reproductibilitate. Se verifică dacă înțelegi legătura dintre mediu, testele vizuale și eșecurile „doar pe CI”.

Eroarea, în practică:browserType.launch: Executable doesn't exist

Î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 automată, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Testare automată scriind cod, nu doar citind

Curs Test Automation (Playwright și Selenium): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 20 lecții sunt gratuite.