...
Pregătire interviuri

100 de întrebări de interviu Postman, cu răspunsuri

Întrebările despre Postman 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 API Testing cu Postman: primele 10 lecții sunt gratuite.

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

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

La un interviu pentru un rol de QA, QA Automation sau backend, Postman apare de obicei în trei forme: întrebări despre unealtă („ce scope-uri de variabile există”, „cum salvezi tokenul după login”), un exercițiu practic în care primești un API și trebuie să trimiți cereri, să scrii teste și să explici ce ai găsit, și discuții despre automatizare, adică rularea colecției cu Newman în CI. Uneori primești o temă de casă: o colecție pentru un API public, iar discuția pornește de la structura ei, de la teste și de la bug-urile raportate.

La nivel de junior se urmărește dacă înțelegi HTTP în practică (metode, coduri de status, antete, body), dacă organizezi o colecție cu medii și variabile, dacă automatizezi autentificarea și dacă scrii teste corecte cu pm.test și pm.expect. La nivel de mid, întrebările merg spre scripturi mai complexe, pm.sendRequest, validare de schemă, testare data-driven, Newman în pipeline și diagnosticarea testelor care pică doar în CI. La senior apar strategia suitei, securitatea de bază a API-urilor, mock-urile pentru echipe care lucrează în paralel și stabilitatea testelor.

Fiecare întrebare are un răspuns scurt, bun de spus în primele secunde, și unul detaliat, cu explicația și scripturile de care ai nevoie la întrebările de continuare. Exemplele folosesc API-ul demo din curs (un magazin online, cu produse, coș și comenzi) și sintaxa actuală din Postman. Încearcă întâi să răspunzi singur, apoi verifică ideile direct în Postman. Pentru teoria generală de testare și REST, vezi și paginile de întrebări pentru meseriile de QA Engineer și Backend Developer.

Cereri HTTP, coduri de status și antete în Postman

1 Junior

Ce se întâmplă, pas cu pas, din momentul în care apeși Send în Postman până vezi rezultatul testelor?

Răspuns scurt: Rulează scripturile Pre-request (colecție, folder, cerere), se înlocuiesc variabilele, se aplică autentificarea, pleacă cererea, vine răspunsul, apoi rulează scripturile Post-response cu testele.

Ordinea exactă contează la depanare:

  • rulează scripturile Pre-request: întâi cel al colecției, apoi al folderului, apoi al cererii;
  • Postman înlocuiește variabilele {{...}} în URL, antete și body, după precedența scope-urilor;
  • se aplică autentificarea (inclusiv cea moștenită de la folder sau colecție) și se adaugă antetele automate (User-Agent, Postman-Token, Content-Type, Content-Length, cookie-urile din jar);
  • cererea pleacă; dacă serverul răspunde cu 3xx și redirecționarea e activă, Postman o urmează;
  • se afișează răspunsul (status, timp, mărime, body, antete, cookie-uri);
  • rulează scripturile Post-response, în aceeași ordine colecție → folder → cerere, iar pm.test produce rezultatele din Test Results.

Din ordinea asta reies câteva lucruri practice. O variabilă setată în pre-request e deja rezolvată când pleacă cererea. O eroare în pre-request oprește trimiterea. Dacă cererea nu primește răspuns (ENOTFOUND, timeout), testele nu au ce verifica. Iar Console arată cererea finală, după toate înlocuirile.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de execuție, fără de care nu poți depana un test. Mulți candidați nu știu că scripturile colecției rulează înaintea celor de pe cerere.

Eroarea, în practică:getaddrinfo ENOTFOUND

2 Junior

Ce informații îți arată panoul de răspuns din Postman și în ce ordine te uiți la ele când verifici un endpoint?

Răspuns scurt: Statusul, timpul și mărimea, apoi body-ul (Pretty, Raw, Preview), antetele, cookie-urile și Test Results. Te uiți întâi la status, apoi la Content-Type și abia apoi la conținut.

Panoul de răspuns are o linie de rezumat și mai multe taburi.

  • Status: codul și textul (201 Created). Spune dacă operația a reușit, înainte să citești orice.
  • Time: durata cererii; un clic pe ea arată defalcarea (DNS, conectare, TLS, așteptare, descărcare), utilă când ceva e lent.
  • Size: mărimea antetelor și a body-ului.
  • Body: Pretty (formatat după tip), Raw (exact ce a venit) și Preview (randat, util pentru HTML).
  • Headers: antetele de răspuns, de exemplu Content-Type, Location, Retry-After, X-Total-Count.
  • Cookies: ce a setat serverul.
  • Test Results: rezultatul fiecărui pm.test.

Ordinea practică: status, apoi Content-Type (dacă e text/html pe un endpoint JSON, nu mai are rost să parsezi body-ul), apoi conținutul și abia apoi detalii ca timpul. Raw e important când Pretty ascunde ceva: spații, caractere ciudate, un body gol.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă un mod sistematic de a citi un răspuns. Greșeala tipică: candidatul se uită doar la body și ratează un 200 venit cu o pagină HTML de eroare.

3 Junior

Ce antete adaugă Postman automat la o cerere și de ce contează asta când compari cu ce trimite browserul sau aplicația?

Răspuns scurt: User-Agent (PostmanRuntime), Postman-Token, Host, Accept, Accept-Encoding, Connection, Cache-Control, plus Content-Type și Content-Length după body. Diferențele față de client pot schimba răspunsul.

Postman pune antete „ascunse”, vizibile în tabul Headers la opțiunea hidden: User-Agent: PostmanRuntime/7.x, Accept: */*, Accept-Encoding: gzip, deflate, br, Connection: keep-alive, Cache-Control: no-cache, Postman-Token (un id unic pe cerere), Host, apoi Content-Type și Content-Length calculate din body și Cookie din cookie jar.

Contează pentru că serverul poate răspunde diferit după antete:

  • un API care verifică Accept poate da JSON în Postman și HTML în browser;
  • un firewall sau un WAF poate bloca anumite User-Agent-uri;
  • Cookie trimis automat poate autentifica o cerere pe care o credeai anonimă;
  • browserul adaugă Origin, deci intră în joc CORS, pe care Postman nu îl aplică.

Când reproduci un bug raportat din aplicație, copiezi antetele reale (din DevTools, ca cURL) și compari cu ce pleacă din Postman. Antetele automate se pot dezactiva sau suprascrie din tabul Headers.

Ce urmărește intervievatorul: Verifică dacă știi că Postman nu e un client neutru. Răspunsul slab: „Postman trimite doar ce scriu eu”.

Eroarea, în practică:socket hang up

4 Junior

Ce înseamnă 201, 202 și 204 și cum ai verifica fiecare într-un test Postman?

Răspuns scurt: 201 Created: resursa a fost creată (de obicei cu Location); 202 Accepted: cererea a fost primită pentru procesare ulterioară; 204 No Content: succes fără body. Testul verifică statusul și ce trebuie să existe sau să lipsească.

Toate sunt coduri de succes, dar promit lucruri diferite, deci și testele diferă.

  • 201 Created: după un POST care creează ceva. Verifici statusul, body-ul cu resursa nouă și antetul Location.
  • 202 Accepted: serverul a acceptat o operație care se termină mai târziu (un export, un import). Verifici că primești un id de job sau o adresă de urmărit, apoi interoghezi starea.
  • 204 No Content: de obicei după DELETE sau PUT; body-ul trebuie să fie gol.
JavaScript
pm.test("201 cu Location", function () {
    pm.response.to.have.status(201);
    pm.response.to.have.header("Location");
});
pm.test("204 fără body", function () {
    pm.response.to.have.status(204);
    pm.expect(pm.response.text()).to.equal("");
});

Atenție la 204: un pm.response.json() pe un body gol aruncă eroare, deci testele copiate de pe alte cereri trebuie adaptate.

Ce urmărește intervievatorul: Se verifică dacă știi diferențele fine dintre codurile 2xx și dacă testul tău le reflectă. Mulți scriu doar status(200) peste tot.

Eroarea, în practică:JSONError: No data, empty input

5 Junior

Primești 405 Method Not Allowed în Postman. Ce înseamnă, ce antet ar trebui să conțină răspunsul și ce verifici ca tester?

Răspuns scurt: Ruta există, dar nu acceptă metoda trimisă. Răspunsul corect conține antetul Allow cu metodele permise. Verifici că ai ales metoda bună și, ca test negativ, că metodele nepermise sunt refuzate.

405 e diferit de 404: serverul recunoaște adresa, dar nu metoda. În Postman apare cel mai des din două motive: metoda a rămas pe GET deși voiai POST, sau ai trimis PUT pe o listă (/products) în loc de un element (/products/7).

Standardul HTTP cere ca răspunsul 405 să aibă antetul Allow, de exemplu Allow: GET, POST. E o informație utilă pentru clienți și pentru tine, ca tester, pentru că îți spune ce metode trebuie testate pe acea rută.

Ca test negativ, încerci metodele care nu ar trebui să funcționeze: un DELETE pe toată lista de produse care ar reuși ar fi un bug grav.

JavaScript
pm.test("DELETE pe listă e refuzat", function () {
    pm.response.to.have.status(405);
    pm.expect(pm.response.headers.get("Allow")).to.include("GET");
});

Un server care răspunde 404 sau 500 în loc de 405 nu e grav, dar merită raportat: clienții nu pot distinge „ruta lipsește” de „metoda e greșită”.

Ce urmărește intervievatorul: Testează diferența 404/405 și cunoașterea antetului Allow. Răspunsul slab confundă 405 cu o problemă de autentificare.

Eroarea, în practică:405 Method Not Allowed

6 Junior

Cum testezi în Postman un endpoint care răspunde cu redirecționare (301 sau 302)?

Răspuns scurt: Dezactivezi „Automatically follow redirects” din Settings-ul cererii, ca să vezi răspunsul 3xx, apoi verifici codul și antetul Location. Cu opțiunea activă, Postman îți arată doar răspunsul final.

Implicit, Postman urmează redirecționările, la fel ca browserul, și vezi direct pagina finală (200). Ca să testezi redirecționarea însăși, deschizi tabul Settings al cererii și dezactivezi Automatically follow redirects.

Apoi verifici:

  • codul potrivit: 301/308 pentru mutare permanentă, 302/307 pentru temporară;
  • antetul Location, cu adresa corectă (absolută sau relativă, după API);
  • că nu există bucle (A trimite la B, B la A).
JavaScript
pm.test("Adresa veche e mutată permanent", function () {
    pm.response.to.have.status(301);
    pm.expect(pm.response.headers.get("Location")).to.match(/\/products$/);
});

O capcană importantă: la 301 și 302, clienții (și Postman) transformă un POST într-un GET când urmează redirecționarea, iar body-ul se pierde. Dacă un formular trimis prin POST ajunge la un endpoint care răspunde 301, rezultatul pare un bug misterios. 307 și 308 păstrează metoda și body-ul.

Ce urmărește intervievatorul: Arată dacă știi că Postman ascunde redirecționările și cum le scoți la vedere. Detaliul despre POST devenit GET separă candidații buni.

Eroarea, în practică:301 Moved Permanently în loc de 200

7 Junior

Ce înseamnă 415 Unsupported Media Type și 422 Unprocessable Entity și ce greșeli din Postman le produc cel mai des?

Răspuns scurt: 415: serverul nu acceptă formatul body-ului, de obicei pentru că Content-Type e greșit (Text în loc de JSON). 422: formatul e bun, dar datele încalcă regulile (email invalid, câmp lipsă).

Cele două coduri apar des când începi să trimiți body-uri.

415 Unsupported Media Type ține de format. Cauze tipice în Postman:

  • body raw lăsat pe Text în loc de JSON, deci pleacă Content-Type: text/plain;
  • un antet Content-Type scris manual în tabul Headers, care suprascrie ce alege Postman;
  • form-data trimis la un endpoint care așteaptă JSON (sau invers, la un endpoint OAuth de tip /token).

422 Unprocessable Entity ține de conținut: JSON-ul e valid, dar un câmp lipsește, are tipul greșit ("cantitate": "2" în loc de 2) sau o valoare în afara regulilor. Un API bun întoarce lista câmpurilor greșite, iar testul tău o verifică.

Unele API-uri folosesc 400 pentru ambele situații; nu e greșit, dar contractul trebuie să fie consecvent. Ca tester, pentru 415 schimbi doar tipul body-ului și vezi dacă eroarea dispare, iar pentru 422 schimbi câte un câmp, ca să vezi exact regula încălcată.

Ce urmărește intervievatorul: Testează dacă poți diagnostica rapid erorile de body. Greșeala tipică: candidatul crede că 415 înseamnă date invalide.

Eroarea, în practică:415 Unsupported Media Type422 Unprocessable Entity

8 Mid

Ce diferență e între antetele Content-Type și Accept și cum ai testa în Postman că un API respectă antetul Accept?

Răspuns scurt: Content-Type descrie formatul body-ului trimis (de tine sau de server), Accept spune ce format vrea clientul înapoi. Testezi trimițând Accept diferit și verificând Content-Type-ul răspunsului sau un 406.

Content-Type apare în ambele direcții: în cerere descrie body-ul tău, în răspuns descrie body-ul serverului. Accept apare doar în cerere și exprimă preferința clientului: application/json, application/xml, text/csv.

Un API care face content negotiation alege formatul după Accept. Testele în Postman:

  • Accept: application/json → răspuns cu Content-Type: application/json;
  • Accept: application/xml → XML, dacă API-ul îl suportă, altfel 406 Not Acceptable (sau JSON, dacă documentația spune că ignoră antetul);
  • fără Accept (Postman trimite */*) → formatul implicit.
JavaScript
pm.test("Respectă Accept: XML", function () {
    pm.expect(pm.response.headers.get("Content-Type")).to.include("application/xml");
    pm.expect(pm.response.text()).to.match(/^<\?xml/);
});

Capcana: Accept: */* trimis implicit de Postman poate ascunde o problemă care apare doar cu aplicația reală, care trimite alt Accept. Când reproduci un bug, copiază antetele exacte ale clientului.

Ce urmărește intervievatorul: Verifică înțelegerea direcției antetelor și a negocierii de conținut. Mulți candidați cred că Content-Type controlează ce primesc înapoi.

Eroarea, în practică:415 Unsupported Media Type

9 Junior

Cum folosești consola Postman ca să vezi exact ce cerere a plecat, după înlocuirea variabilelor?

Răspuns scurt: Deschizi Console (jos sau View → Show Postman Console): pentru fiecare cerere vezi URL-ul final, antetele trimise, body-ul, răspunsul și mesajele console.log din scripturi.

Editorul de cereri arată șablonul ({{baseUrl}}/products/{{id}}), nu ce a plecat. Consola arată cererea reală:

  • URL-ul după înlocuirea variabilelor și după adăugarea parametrilor de autentificare;
  • antetele trimise, inclusiv cele automate și Authorization generat;
  • body-ul trimis;
  • răspunsul primit, cu antete;
  • erorile de rețea (ENOTFOUND, ECONNREFUSED) și erorile din scripturi;
  • tot ce scrii cu console.log, console.warn, console.error.

În practică, consola rezolvă rapid trei tipuri de probleme: o variabilă care s-a rezolvat altfel decât credeai (alt environment, alt scope), un antet trimis în plus sau lipsă și un script care a salvat undefined. Când atașezi o cerere la un raport de bug, informațiile din consolă (URL final, antete, body) sunt mai valoroase decât o captură a editorului.

Consola se golește manual; dacă rulezi mult, golește-o înainte de cererea pe care o investighezi.

Ce urmărește intervievatorul: Intervievatorul vrea să știe dacă ai o metodă de depanare. Candidații slabi depanează „din ochi”, schimbând lucruri la întâmplare.

Eroarea, în practică:Could not send request

10 Mid

Cum gestionează Postman cookie-urile și cum îți pot strica un test de autorizare?

Răspuns scurt: Postman păstrează cookie-urile primite în Set-Cookie într-un cookie jar, pe domeniu, și le trimite automat la următoarele cereri. O cerere „fără autentificare” poate pleca totuși autentificată prin cookie-ul de sesiune.

Postman se comportă ca un browser: când serverul trimite Set-Cookie, cookie-ul intră în cookie jar, legat de domeniu și cale, iar cererile următoare către același domeniu îl trimit automat în antetul Cookie. Cookie-urile se văd în tabul Cookies al răspunsului și se gestionează din fereastra Cookies (sub butonul Send).

Problema la testarea autorizării: faci login (care setează cookie-ul session), apoi testezi că GET /users fără token dă 401. Cererea pleacă fără Authorization, dar cu cookie-ul, și serverul o autentifică. Testul pică, iar tu crezi că ai găsit un bug.

Cum eviți:

  • testele anonime le rulezi înainte de login sau după golirea cookie-urilor;
  • în Console verifici antetul Cookie trimis;
  • poți dezactiva trimiterea cookie-urilor pentru o cerere sau poți șterge cookie-ul din script cu pm.cookies.jar().clear(...).

Cookie-urile merită și ele testate: atributele HttpOnly, Secure, SameSite și expirarea sunt verificări de securitate.

Ce urmărește intervievatorul: Testează experiența practică: problema apare exact la testele de acces. Răspunsul slab ignoră complet cookie-urile.

11 Mid

O cerere durează 4 secunde în Postman. Cum folosești detaliile de timp ca să afli unde se pierde timpul?

Răspuns scurt: Dai clic pe timpul din răspuns și vezi defalcarea: DNS, conectare TCP, TLS, așteptarea primului byte și descărcarea. Dacă domină așteptarea, problema e pe server; dacă domină DNS sau conectarea, e rețeaua.

Timpul afișat lângă status e un total. Clic pe el deschide defalcarea:

  • Socket initialization și DNS lookup: rezolvarea numelui; valori mari indică un DNS lent sau un nume greșit care se rezolvă greu;
  • TCP handshake: conectarea la server; mare când serverul e departe sau supraîncărcat;
  • SSL handshake: negocierea TLS;
  • Waiting (TTFB): timpul până la primul byte, adică procesarea pe server;
  • Download: transferul răspunsului; mare la body-uri uriașe.

În 90% din cazuri domină TTFB, deci problema e în aplicație sau în baza de date. Atunci repeți cererea cu parametri diferiți (fără filtre, cu limit mic) ca să izolezi cauza și pui în raport cererea exactă și timpii.

Dacă domină Download, verifici mărimea: poate endpointul întoarce 5.000 de elemente fără paginare. Dacă prima cerere e lentă și următoarele rapide, e efectul de „încălzire” (cache, conexiune nouă), deci măsori de mai multe ori înainte să tragi concluzii.

Ce urmărește intervievatorul: Verifică dacă știi să transformi „e lent” într-o observație utilă pentru dezvoltatori. Candidatul slab raportează doar cifra totală.

Eroarea, în practică:ESOCKETTIMEDOUTconnect ETIMEDOUT

12 Mid

Un dezvoltator îți spune că un bug apare doar în aplicație, nu și în Postman. Cum reproduci exact cererea aplicației?

Răspuns scurt: Din DevTools → Network copiezi cererea ca cURL și o imporți în Postman (Import → Raw text). Apoi compari antetele, cookie-urile și body-ul cu cererea ta și elimini diferențele una câte una.

Cea mai sigură metodă e să nu rescrii cererea de mână:

1. În browser, DevTools → Network, clic dreapta pe cerere → Copy as cURL. 2. În Postman, Import → Raw text, lipești comanda; Postman creează cererea cu metoda, URL-ul, antetele și body-ul exacte. 3. Trimiți și compari cu cererea ta „curată”.

Diferențele tipice care explică „la mine merge”:

  • un antet pe care aplicația îl trimite și tu nu (Accept-Language, o versiune de API, un X-Client);
  • cookie-uri de sesiune sau un token alt utilizator;
  • body serializat altfel (număr trimis ca șir, câmp null în loc de lipsă);
  • Origin din browser, care declanșează reguli CORS pe care Postman nu le aplică.

Apoi elimini antetele unul câte unul până când bug-ul dispare: ultimul eliminat e cauza. Atenție, comanda cURL copiată conține tokenuri și cookie-uri reale; le ștergi înainte să o pui într-un tichet.

Ce urmărește intervievatorul: Arată că ai o metodă reproductibilă de izolare, nu doar „am încercat și merge”. Mențiunea despre datele sensibile din cURL e un plus.

13 Senior

Cum testezi în Postman cache-ul HTTP al unui API, cu ETag și cererile condiționate?

Răspuns scurt: Prima cerere întoarce ETag; salvezi valoarea și o trimiți în If-None-Match. Serverul trebuie să răspundă 304 fără body dacă resursa nu s-a schimbat și 200 cu ETag nou după o modificare.

Cache-ul se testează ca un mic flux în trei pași.

1. Cererea inițială salvează ETag-ul:

JavaScript
pm.test("Are ETag și Cache-Control", function () {
    pm.response.to.have.header("ETag");
});
pm.collectionVariables.set("etag", pm.response.headers.get("ETag"));

2. Cererea condiționată trimite If-None-Match: {{etag}} și așteaptă 304 Not Modified, fără body. E economia de bandă pentru care există mecanismul.

3. După o modificare (PUT pe resursă), aceeași cerere condiționată trebuie să dea 200 cu un ETag diferit. Dacă tot vine 304, clienții văd date vechi, un bug greu de prins în aplicație.

Mai verifici:

  • Cache-Control potrivit tipului de date (no-store pe date personale, max-age pe catalog);
  • că un PUT cu If-Match și ETag vechi e refuzat cu 412 Precondition Failed (protecție la actualizări concurente);
  • că Postman nu îți ascunde efectul: trimite implicit Cache-Control: no-cache, deci uită-te în Console la antetele reale.

Ce urmărește intervievatorul: Întrebare de nivel senior: verifică dacă știi HTTP dincolo de metode și coduri. Partea cu 412 și actualizările concurente face diferența.

Colecții, documentație și lucru în echipă

14 Junior

Ce e o colecție în Postman și ce elemente poate conține în afară de cereri?

Răspuns scurt: Un grup de cereri salvate, organizate în foldere. Colecția are propriile variabile, autentificare, scripturi pre-request și de test, documentație și exemple de răspuns, moștenite de cererile din ea.

O colecție e unitatea de lucru din Postman: tot ce testezi pentru un API stă într-una. Pe lângă cereri, are:

  • foldere, ca să grupezi cererile pe resurse (Produse, Comenzi, Auth) sau pe fluxuri;
  • variabile de colecție, valabile pentru toate cererile din ea (de exemplu productId);
  • Authorization la nivel de colecție sau folder, moștenită de cererile setate pe *Inherit auth from parent*;
  • scripturi Pre-request și Post-response care rulează pentru fiecare cerere, bune pentru verificări comune;
  • documentație: descrieri în Markdown pe colecție, foldere și cereri;
  • exemple salvate de răspunsuri, folosite de documentație și de mock servers.

Colecția se poate rula integral cu Collection Runner sau Newman, se poate exporta ca fișier JSON (format v2.1) și se poate partaja în workspace-ul echipei.

Diferența practică față de istoric (History): cererile din istoric sunt temporare și fără teste; ce merită repetat se salvează în colecție.

Ce urmărește intervievatorul: Verifică vocabularul de bază. Un răspuns bun arată că știi ce se moștenește de la colecție, nu doar că „e un folder cu cereri”.

15 Junior

Cum ai organiza colecția pentru un API de magazin online cu produse, utilizatori, coș și comenzi?

Răspuns scurt: Un folder pentru autentificare la început, apoi câte un folder pe resursă (Produse, Coș, Comenzi, Utilizatori), cu subfoldere pentru cazuri pozitive și negative, plus un folder separat pentru fluxuri end-to-end.

O structură clară arată cam așa:

Magazin API
├── 00 Auth (login client, login admin, refresh)
├── Produse
│   ├── Pozitiv (listă, filtre, detaliu, căutare)
│   └── Negativ (id inexistent, filtre invalide)
├── Coș
├── Comenzi
├── Admin (creare/ștergere produse)
└── Fluxuri (cumpărare completă, anulare)

Principiile din spate:

  • Auth primul, ca o rulare completă să obțină tokenurile înainte de restul;
  • un folder pe resursă, ca să găsești repede o cerere și să rulezi doar o parte (newman --folder Produse);
  • cazurile negative separate, ca să le poți rula sau ignora în bloc;
  • fluxurile separate de testele pe endpoint, pentru că depind de ordine;
  • nume descriptive: „GET produs inexistent → 404”, nu „Request 7”.

La nivel de folder pui autentificarea (Admin cu token de admin, Produse fără) și scripturile comune. Un prefix numeric (00, 01) păstrează ordinea dorită la rulare.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă gândești colecția ca pe o suită de teste întreținută, nu ca pe o grămadă de cereri.

16 Junior

Ce sunt exemplele (examples) salvate pe o cerere și la ce folosesc?

Răspuns scurt: Perechi cerere-răspuns salvate ca referință (de exemplu 200 și 404). Apar în documentație, ajută colegii să vadă formatul fără să trimită cereri și sunt sursa răspunsurilor pentru mock servers.

Un exemplu e un răspuns salvat pe o cerere, împreună cu cererea care l-a produs: status, antete și body. Îl creezi cu Save Response → Save as example după ce trimiți cererea sau îl scrii de mână.

La ce folosesc:

  • documentație: în documentația generată, fiecare cerere arată exemplele, deci cine citește vede imediat formatul răspunsului de succes și al erorilor;
  • mock servers: un mock răspunde cu exemplul care se potrivește cel mai bine cu metoda, calea și, opțional, cu antetul x-mock-response-code sau x-mock-response-name;
  • referință pentru teste: un exemplu salvat la momentul X arată cum arăta contractul, util când compari după o schimbare.

O practică bună: pentru fiecare endpoint salvezi cel puțin un exemplu de succes și unul de eroare (404, 422). Atenție să nu salvezi în exemple tokenuri sau date personale reale, pentru că exemplele sunt vizibile oricui vede colecția.

Ce urmărește intervievatorul: Verifică dacă folosești Postman pentru documentare și lucru în echipă, nu doar pentru trimis cereri.

17 Junior

Cum generezi și publici documentația unei colecții în Postman?

Răspuns scurt: Scrii descrieri în Markdown pe colecție, foldere, cereri și parametri, salvezi exemple de răspuns, apoi deschizi View documentation. Documentația se poate publica public sau partaja în workspace.

Postman generează documentația direct din colecție, deci calitatea ei depinde de ce completezi:

  • descrierea colecției: scopul API-ului, adresa de bază, cum obții acces, convenții (format de dată, paginare, erori);
  • descrierea folderelor: ce resursă acoperă;
  • descrierea cererilor: ce face endpointul, ce drepturi cere;
  • descrierea parametrilor din Params și Headers (coloana Description);
  • exemplele de răspuns, care apar lângă fiecare cerere.

Din meniul colecției alegi View documentation. De acolo poți partaja în workspace sau o poți publica la o adresă publică, cu un environment ales pentru valorile afișate.

Ca tester, documentația te ajută în două feluri: o citești ca specificație când primești un API nou și o întreții, adăugând cazurile de eroare descoperite. Atenție la publicare: valorile din environment-ul ales apar în documentație, deci nu publici niciodată cu un environment care conține secrete.

Ce urmărește intervievatorul: Se verifică dacă știi că documentația vine din colecție. Mențiunea despre secretele expuse la publicare arată maturitate.

18 Junior

Cum lucrezi cu colegii pe aceeași colecție Postman fără să vă stricați munca unul altuia?

Răspuns scurt: Colecția stă într-un workspace de echipă. Pentru schimbări mari faci fork, lucrezi pe copie și deschizi pull request, pe care un coleg îl revizuiește înainte de merge. Pentru echipe mici, comentariile și istoricul de modificări ajută.

Postman are mecanisme de colaborare asemănătoare cu git:

  • Team workspace: colecțiile și environment-urile sunt vizibile echipei, cu roluri (Viewer, Editor);
  • Fork: copie personală a colecției, pe care o modifici fără să afectezi originalul;
  • Pull request: propui schimbările din fork, un coleg vede diferențele, comentează și aprobă;
  • Merge: schimbările intră în colecția principală;
  • Changelog: istoricul modificărilor, cu posibilitatea de a reveni;
  • comentarii pe cereri, pentru discuții punctuale.

În practică, schimbările mici (un test nou) se pot face direct, iar restructurările sau schimbările de autentificare trec prin fork și pull request.

O problemă frecventă: Current value al variabilelor e local, deci colegul nu vede tokenul tău, iar Initial value e partajat. Dacă pui o parolă în Initial value, o vede toată echipa. Alternativa, dacă echipa preferă git, e exportul colecției ca JSON în repository, cu review în pull request-urile obișnuite.

Ce urmărește intervievatorul: Verifică experiența de lucru în echipă. Diferența Initial/Current value legată de colaborare e un detaliu pe care îl știu doar cei care au folosit Postman serios.

19 Mid

Ce formate poți importa în Postman și ce verifici după ce imporți o specificație OpenAPI?

Răspuns scurt: Colecții Postman (v2.0/v2.1), OpenAPI/Swagger, cURL, RAML, GraphQL, WSDL, HAR. După import verifici structura folderelor, variabila baseUrl, autentificarea, body-urile generate și faptul că exemplele sunt realiste.

Prin Import poți aduce: colecții și environment-uri Postman exportate (JSON), specificații OpenAPI 3 și Swagger 2, comenzi cURL, RAML, schema GraphQL, WSDL pentru SOAP și fișiere HAR din browser.

Importul unei specificații OpenAPI generează o colecție cu câte o cerere pe operație, grupate după tag-uri sau după cale. E un început bun, nu o suită de teste. După import verifici:

  • baseUrl: se creează o variabilă din servers; corect e să pointeze spre mediul de test, nu spre producție;
  • autentificarea din securitySchemes: uneori trebuie configurată manual pe colecție;
  • body-urile generate din scheme: au valori generice ("string", 0) pe care le înlocuiești cu date valide;
  • parametrii de cale (:id) și cei obligatorii de query;
  • numele cererilor, generate din summary, uneori lungi.

Apoi adaugi teste, exemple de eroare și foldere pentru cazuri negative. Un plus: diferențele dintre specificație și răspunsurile reale, găsite chiar la primul import, sunt deja bug-uri de documentație.

Ce urmărește intervievatorul: Verifică dacă știi să pornești rapid de la o specificație, dar și că nu confunzi colecția generată cu una testată.

20 Mid

Testele din colecția ta trec doar dacă rulezi cererile într-o anumită ordine. E o problemă? Cum o rezolvi?

Răspuns scurt: Depinde: într-un flux (login, creare, citire, ștergere) ordinea e intenționată. Pentru testele pe endpoint, dependența e fragilă; fiecare cerere ar trebui să-și pregătească singură datele sau să folosească date fixe cunoscute.

Sunt două tipuri de cereri într-o colecție bună.

Fluxurile depind intenționat de ordine: login → adaug în coș → plasez comanda → verific comanda. Acolo ordinea e chiar ce testezi, iar cererile își transmit date prin variabile. E acceptabil, dacă fluxul e clar marcat și rulează mereu întreg.

Testele pe endpoint n-ar trebui să depindă de ce a rulat înainte. Dacă „GET comanda” trece doar după „POST comanda”, nu poți rula cererea singură, nu poți rula doar un folder și orice eșec la început produce o cascadă de eșecuri înșelătoare.

Soluții:

  • date de test fixe, cunoscute (produsul 7 există mereu în mediul de test);
  • un pre-request care creează ce lipsește, de exemplu cu pm.sendRequest sau verificând că variabila există;
  • login la nivel de colecție, cu token reîmprospătat automat, în loc de o cerere de login obligatorie;
  • curățenie: ce creezi, ștergi la sfârșit, ca rularea următoare să pornească la fel.

Regula practică: orice cerere din afara folderului Fluxuri trebuie să treacă și rulată singură.

Ce urmărește intervievatorul: Testează înțelegerea independenței testelor aplicată la Postman. Răspunsul slab: „rulez mereu toată colecția, deci e ok”.

Eroarea, în practică:401 în Runner, deși merge la Send

21 Mid

Cum versionezi o colecție Postman și cum o legi de codul API-ului?

Răspuns scurt: Exporți colecția și environment-ul fără secrete ca JSON în repository-ul API-ului, la fiecare schimbare, sau folosești integrarea Postman cu git. Astfel testele se schimbă în același pull request cu codul și rulează cu Newman în CI.

Colecția e cod de test, deci trebuie versionată lângă codul pe care îl testează. Variante:

  • export manual în repository: postman/magazin.postman_collection.json și un environment fără secrete. Simplu, dar depinde de disciplina echipei;
  • integrarea cu git a Postman sau API-urile Postman pentru sincronizare automată;
  • Postman API + CI: pipeline-ul descarcă ultima versiune a colecției din workspace înainte de rulare.

Avantajul exportului în repository: când un dezvoltator schimbă un endpoint, actualizează testele în același pull request, iar Newman rulează în CI exact versiunea potrivită codului. Când colecția trăiește doar în cloud, testele pot fi „din viitor” sau „din trecut” față de codul testat.

Câteva reguli: environment-ul din git are doar valori nesecrete, secretele vin din variabilele CI (--env-var); exportul se face în formatul v2.1; review-ul pe un JSON mare e greu, deci mesajele de commit trebuie să spună ce s-a schimbat.

Ce urmărește intervievatorul: Verifică dacă tratezi testele API ca parte din livrare. Candidații fără experiență de CI nu se gândesc la sincronizarea cu codul.

22 Mid

Cum folosești Postman pentru a testa un API GraphQL?

Răspuns scurt: Alegi body GraphQL (sau o cerere de tip GraphQL), scrii query-ul și variabilele separat, iar Postman poate încărca schema prin introspecție pentru autocompletare. În teste verifici data și, separat, lista errors, pentru că GraphQL răspunde des cu 200 și la erori.

GraphQL folosește de obicei un singur endpoint (POST /graphql), deci testarea diferă de REST.

În Postman ai două variante: o cerere HTTP cu body de tip GraphQL sau tipul dedicat de cerere GraphQL, care face introspecția schemei și oferă autocompletare. Query-ul și variabilele se scriu separat:

GRAPHQL
query Produs($id: ID!) { produs(id: $id) { nume pret stoc } }

Capcana principală: multe servere GraphQL întorc 200 chiar dacă query-ul a eșuat, cu un câmp errors. Un test pe status nu e suficient:

JavaScript
pm.test("Fără erori GraphQL", function () {
    const j = pm.response.json();
    pm.expect(j.errors, JSON.stringify(j.errors)).to.be.undefined;
    pm.expect(j.data.produs.pret).to.be.a("number");
});

Ce mai testezi: câmpuri cerute care nu există (eroare de validare), autorizare pe câmpuri, query-uri foarte adânci sau foarte mari (limite de complexitate) și faptul că răspunsul conține doar câmpurile cerute.

Ce urmărește intervievatorul: Testează adaptarea la alt stil de API. Detaliul despre 200 cu errors e exact ce urmărește intervievatorul.

23 Senior

Moștenești o colecție Postman cu 300 de cereri, fără structură, cu teste duplicate și variabile împrăștiate. Cum o refactorizezi?

Răspuns scurt: Întâi inventar: ce rulează, ce trece, ce e folosit în CI. Apoi structură pe resurse, autentificare și verificări comune mutate la nivel de colecție, variabile consolidate, nume clare, cereri moarte șterse. Totul în pași mici, cu rulări Newman între ei.

O refactorizare mare nu se face dintr-o dată, pentru că nu știi ce depinde de ce.

1. Inventar. Rulezi colecția cu Newman și salvezi raportul ca punct de plecare: câte cereri trec, câte pică, câte n-au teste. Afli cine o folosește (CI, alți colegi, monitoare).

2. Structură. Foldere pe resursă și un folder de fluxuri, cereri redenumite după convenție (METODĂ resursă - caz → status).

3. Duplicare. Verificările repetate (status 2xx, timp, Content-Type) le muți în scriptul Post-response al colecției. Autentificarea o setezi pe colecție sau folder, cu *Inherit auth* pe cereri.

4. Variabile. Un singur baseUrl în environment, ID-uri în variabile de colecție, globale doar dacă e absolut necesar. Cauți în export valorile scrise de mână (URL-uri, tokenuri) și le înlocuiești.

5. Curățenie. Cererile fără teste și nefolosite trec într-un folder „Arhivă”, apoi se șterg după o perioadă.

După fiecare pas rulezi din nou Newman și compari cu punctul de plecare. Lucrezi într-un fork, cu pull request, ca echipa să vadă schimbările.

Ce urmărește intervievatorul: Întrebare senior despre mentenanță și risc. Se urmărește abordarea incrementală, cu măsurare înainte și după, nu „o rescriu de la zero”.

Variabile, scope-uri și medii

Exersează capitolul cu exerciții reale: Curs Postman →
24 Junior

Ce scope-uri de variabile are Postman și în ce ordine se rezolvă când același nume există în mai multe?

Răspuns scurt: Global, colecție, environment, data (din fișierul de date) și local (setate din script). Câștigă cel mai îngust: local, apoi data, environment, colecție și la final global.

Postman are cinci scope-uri, de la cel mai larg la cel mai îngust:

  • Global: valabile în tot workspace-ul;
  • Collection: legate de o colecție;
  • Environment: legate de mediul selectat (Dev, Staging);
  • Data: valorile din fișierul CSV/JSON la o rulare data-driven, pe iterația curentă;
  • Local: setate cu pm.variables.set(), valabile doar în cererea sau rularea curentă.

Când {{baseUrl}} există în mai multe locuri, se folosește cel mai îngust: local > data > environment > collection > global.

Consecința practică e o sursă clasică de confuzie: modifici baseUrl în environment, dar cererea pleacă tot spre adresa veche, pentru că există o variabilă locală sau de date cu același nume. Invers, setezi o globală și nu are efect, pentru că environment-ul o acoperă.

Când nu știi de unde vine o valoare, treci cu mouse-ul peste {{variabilă}}: Postman arată valoarea și scope-ul din care vine. Din script, pm.variables.get() întoarce valoarea după aceeași precedență, iar pm.environment.get() citește doar din environment.

Ce urmărește intervievatorul: Verifică dacă știi precedența, nu doar lista. Exemplul cu variabila „care nu se schimbă” arată experiență reală.

Eroarea, în practică:Unresolved VariableVariabila are altă valoare (precedența scope-urilor)

25 Junior

Ce diferență e între Initial value și Current value la o variabilă și de ce contează pentru securitate?

Răspuns scurt: Initial value se sincronizează cu echipa și intră în export; Current value e doar local, pe calculatorul tău, și e folosit la trimiterea cererilor. Secretele (parole, tokenuri) se țin doar în Current value.

Fiecare variabilă din environment sau din colecție are două valori.

  • Initial value: partajată. O văd colegii din workspace, se sincronizează în cloud și apare când exporți colecția sau environment-ul.
  • Current value: locală. E valoarea folosită efectiv când trimiți cererea și nu pleacă din calculatorul tău (implicit).

Când un script face pm.environment.set("token", ...), schimbă Current value. De aceea un coleg nu primește tokenul tău și trebuie să facă singur login.

Regula de securitate: parolele, tokenurile și cheile API nu stau în Initial value. Altfel ajung la toată echipa, în exporturi, în repository și, dacă publici documentația cu acel environment, pe internet. Postman oferă și tipul secret pentru variabile (valoarea e mascată pe ecran) și un Vault local pentru secrete, citit cu pm.vault.get().

Capcana inversă: pui baseUrl doar în Current value, iar colegul care importă environment-ul primește variabila goală și vede getaddrinfo ENOTFOUND.

Ce urmărește intervievatorul: Întrebare de securitate deghizată în întrebare despre interfață. Răspunsul slab: „sunt același lucru, una e valoarea de start”.

26 Junior

La ce folosesc environment-urile în Postman și ce variabile pui de obicei într-un environment?

Răspuns scurt: Un environment e un set de variabile pentru un mediu (Local, Dev, Staging). Schimbi mediul din selector fără să modifici cererile. Pui baseUrl, credențiale de test, ID-uri care diferă între medii și tokenul obținut la login.

Aceeași colecție trebuie să ruleze pe mai multe medii. În loc să editezi URL-urile, folosești {{baseUrl}} în cereri și creezi câte un environment pentru fiecare mediu:

| Variabilă | Local | Staging | |---|---|---| | baseUrl | http://localhost:3000 | https://api-staging.firma.ro | | email | test@local | qa@firma.ro |

Schimbi mediul din selectorul din dreapta-sus, iar toate cererile pleacă spre alt server.

Ce pui de obicei într-un environment:

  • adresa de bază (baseUrl, uneori și authUrl);
  • utilizatori de test pentru mediul respectiv;
  • ID-uri care diferă între medii (un produs de test cu ID-ul 7 pe Staging și 1042 pe Dev);
  • tokenul obținut la login (setat din script, doar în Current value).

Ce nu pui în environment: ID-urile create în timpul unei rulări, care se potrivesc mai bine în variabile de colecție sau locale, și valorile identice pe toate mediile, care stau mai bine în colecție. Un detaliu util: dacă nu e selectat niciun environment, pm.environment.set nu are unde să scrie.

Ce urmărește intervievatorul: Verifică folosirea corectă a mediilor, inclusiv ce nu pui acolo. Intervievatorul urmărește dacă separi configurația de date.

Eroarea, în practică:connect ECONNREFUSED 127.0.0.1connect ECONNREFUSED ::1:8080

27 Junior

Ce sunt variabilele dinamice precum {{$guid}}, {{$timestamp}} și {{$randomEmail}} și când le folosești?

Răspuns scurt: Variabile predefinite generate la fiecare cerere: un GUID, timpul Unix, un email aleator și altele. Le folosești ca să creezi date unice, de exemplu la înregistrare, ca testele să nu pice pe „email deja folosit”.

Postman are câteva zeci de variabile dinamice, cu prefixul $, generate la fiecare folosire:

  • {{$guid}}: un identificator unic (UUID v4);
  • {{$timestamp}}: timpul curent Unix, în secunde;
  • {{$isoTimestamp}}: data în format ISO;
  • {{$randomInt}}: un număr între 0 și 1000;
  • {{$randomEmail}}, {{$randomFirstName}}, {{$randomPhoneNumber}}: date false realiste.

Cazul tipic: testul de înregistrare. Cu un email fix, prima rulare trece, iar a doua primește 409 email deja folosit. Cu {{$randomEmail}}, fiecare rulare creează un utilizator nou.

Două capcane:

  • valoarea se generează din nou la fiecare apariție, deci dacă folosești {{$randomEmail}} în body și apoi vrei să verifici în test același email, nu îl ai. Soluția: îl generezi în pre-request și îl salvezi: pm.variables.set("email", pm.variables.replaceIn("{{$randomEmail}}"));
  • datele aleatoare fac eșecurile greu de reprodus, deci în raport incluzi valoarea folosită.

Idempotency-Key și alte antete unice sunt alt caz bun pentru {{$guid}}.

Ce urmărește intervievatorul: Verifică dacă știi să faci teste repetabile. Capcana cu valoarea regenerată la fiecare apariție separă practicienii.

Eroarea, în practică:{{randomEmail}} fără $ trimis literal

28 Junior

O variabilă apare cu roșu în URL și cererea pleacă spre „{{baseUrl}}/products”. Ce înseamnă și cum depanezi?

Răspuns scurt: Variabila nu e definită în niciun scope activ: environment neselectat, nume greșit (majuscule), valoare doar în alt environment sau Current value gol. Verifici selectorul de environment, numele exact și tooltip-ul variabilei.

Roșu înseamnă variabilă nerezolvată: Postman nu a găsit numele în niciun scope activ și trimite textul literal, deci eroarea tipică e getaddrinfo ENOTFOUND {{baseurl}} sau o adresă invalidă.

Verificări, în ordine:

1. Environment-ul selectat: e selectat cel corect, nu „No environment”? 2. Numele exact: variabilele sunt sensibile la majuscule; baseUrl și baseURL sunt diferite. Spațiile din {{ baseUrl }} contează și ele. 3. Valoarea curentă: variabila poate exista, dar cu Current value gol (de exemplu după un import, dacă Initial value e gol). 4. Scope-ul: poate e definită în alt environment sau în altă colecție. 5. Tooltip-ul: mouse peste variabilă arată scope-ul și valoarea, sau mesajul că nu există.

Din script, aceleași probleme apar ca undefined: pm.environment.get("token") întoarce undefined, iar antetul pleacă Bearer undefined. Un test de siguranță în pre-request (pm.expect(pm.environment.get("baseUrl")).to.be.a("string")) face eroarea evidentă de la prima cerere.

Ce urmărește intervievatorul: Întrebare practică foarte frecventă. Se urmărește un proces de verificare, nu ghicitul cauzei.

Eroarea, în practică:getaddrinfo ENOTFOUND {{baseurl}}Unresolved Variable

29 Junior

Ce diferență e între pm.variables, pm.environment, pm.collectionVariables și pm.globals în scripturi?

Răspuns scurt: pm.environment, pm.collectionVariables și pm.globals citesc și scriu într-un scope anume. pm.variables.get citește după precedență din toate scope-urile, iar pm.variables.set scrie doar o variabilă locală, temporară.

Fiecare obiect lucrează cu un scope:

  • pm.globals.get/set: variabilele globale;
  • pm.collectionVariables.get/set: variabilele colecției curente;
  • pm.environment.get/set: environment-ul selectat;
  • pm.iterationData.get: valoarea din fișierul de date pentru iterația curentă (doar citire);
  • pm.variables.get: caută după precedență, exact ca {{...}} în cerere;
  • pm.variables.set: setează o variabilă locală, care dispare la finalul rulării.

Alegerea corectă:

  • citești cu pm.variables.get când nu te interesează de unde vine valoarea, ca scriptul să meargă și din Runner cu fișier de date;
  • scrii tokenul în pm.environment (diferă pe mediu);
  • scrii un ID creat în pm.collectionVariables sau, dacă e folosit doar în aceeași cerere, cu pm.variables.set;
  • globalele le eviți: sunt vizibile în toate colecțiile și produc conflicte de nume.

Greșeala clasică: setezi cu pm.variables.set("orderId", ...) în cererea A și citești în cererea B la trimitere manuală. Variabila locală nu mai există, deci B primește {{orderId}} nerezolvat.

Ce urmărește intervievatorul: Testează dacă știi unde ajunge efectiv o valoare scrisă din script. Greșeala cu variabila locală între cereri e foarte des întâlnită.

Eroarea, în practică:pm.environment.set fără environment selectatVariabila are altă valoare (precedența scope-urilor)

30 Mid

De ce o variabilă salvată ca obiect sau număr nu se comportă cum te aștepți și cum salvezi corect un obiect?

Răspuns scurt: Variabilele Postman stochează text. Un număr devine șir, iar un obiect salvat direct devine „[object Object]”. Salvezi obiectele cu JSON.stringify și le citești cu JSON.parse; numerele le convertești înapoi cu Number.

Variabilele din Postman sunt, în esență, șiruri de caractere, pentru că ajung în URL, antete și body ca text.

Ce se întâmplă:

JavaScript
pm.collectionVariables.set("pret", 89);          // devine "89" la citire, în multe versiuni
pm.collectionVariables.set("produs", { id: 7 }); // poate deveni "[object Object]"

Consecințe tipice:

  • pm.expect(j.price).to.equal(pm.collectionVariables.get("pret")) pică cu „expected 89 to equal '89'”;
  • un body {"items": {{cos}}} devine JSON invalid dacă variabila conține [object Object].

Varianta corectă:

JavaScript
pm.collectionVariables.set("cos", JSON.stringify(j.items));
const cos = JSON.parse(pm.collectionVariables.get("cos"));
const pret = Number(pm.collectionVariables.get("pret"));

În body, o variabilă numerică se scrie fără ghilimele ("quantity": {{cantitate}}), ca să rămână număr în JSON, iar una text cu ghilimele ("email": "{{email}}"). Inversul produce erori 422 de tip, greu de observat la prima vedere.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum circulă datele prin variabile. Greșeala cu ghilimelele în body e foarte frecventă la interviurile practice.

Eroarea, în practică:"undefined" is not valid JSON"[object Object]" is not valid JSON

31 Mid

Ce face pm.variables.replaceIn() și când îți este util?

Răspuns scurt: Înlocuiește variabilele {{...}} dintr-un text, inclusiv cele dinamice, folosind precedența obișnuită. E util ca să generezi o valoare dinamică o singură dată și s-o păstrezi, sau să rezolvi variabile în texte construite din script.

pm.variables.replaceIn(text) face din script ce face Postman automat în cerere: înlocuiește fiecare {{nume}} cu valoarea din scope-ul câștigător și generează variabilele dinamice.

Cazuri utile:

1. Păstrarea unei valori aleatoare. {{$randomEmail}} se regenerează la fiecare folosire. Ca să folosești același email în body și în test:

JavaScript
// Pre-request
const email = pm.variables.replaceIn("{{$randomEmail}}");
pm.variables.set("email", email);

2. Body-ul rezolvat. pm.request.body.raw conține textul cu {{...}}; dacă vrei să calculezi o semnătură HMAC peste body-ul care pleacă efectiv, rezolvi întâi variabilele:

JavaScript
const body = pm.variables.replaceIn(pm.request.body.raw);

3. Construirea unui URL pentru pm.sendRequest dintr-un șablon cu variabile.

O capcană: dacă o variabilă nu există, replaceIn lasă textul {{nume}} neschimbat, fără eroare. Când calculezi ceva important, verifici că rezultatul nu mai conține {{.

Ce urmărește intervievatorul: Întrebare de nivel mediu despre scripturi. Exemplul cu semnătura peste body-ul rezolvat arată experiență cu API-uri reale.

32 Mid

Cum păstrezi curat environment-ul după rulări repetate, ca testele să nu depindă de valori rămase de la rularea anterioară?

Răspuns scurt: Datele temporare le pui în variabile locale sau de colecție, la final le ștergi cu unset, iar la începutul fluxului le resetezi explicit. Environment-ul rămâne doar pentru configurație și token.

Problema apare insidios: o rulare setează orderId, iar rularea următoare trece chiar dacă cererea de creare a picat, pentru că folosește ID-ul vechi. Testul minte.

Practici care o previn:

  • scope-ul potrivit: valorile care trăiesc doar într-o cerere le pui cu pm.variables.set (locale); cele dintr-un flux, în variabile de colecție;
  • curățenie la final: ultima cerere a fluxului face pm.collectionVariables.unset("orderId");
  • resetare la început: prima cerere a fluxului șterge ce ar putea rămâne;
  • verificare la folosire: în pre-request, pm.expect(pm.collectionVariables.get("orderId"), "orderId lipsește").to.exist, ca eroarea să fie clară;
  • set doar la succes: salvezi ID-ul doar dacă statusul e cel așteptat, nu din orice răspuns.

În Collection Runner, opțiunea Persist responses/variables decide dacă valorile setate în rulare rămân după ea; în CI, Newman pornește de la fișierul de environment, deci problema apare mai ales local. Pentru a vedea ce a rămas, compari environment-ul înainte și după.

Ce urmărește intervievatorul: Verifică dacă știi că testele cu stare se pot minți singure. Răspunsul bun include „setez doar la succes”.

33 Mid

Cum lucrezi cu secrete (parole, chei API) în Postman, astfel încât să nu ajungă în export, în git sau la colegi?

Răspuns scurt: Le ții doar în Current value sau în Postman Vault, marchezi variabilele ca secret, nu le scrii niciodată direct în cereri și, în CI, le injectezi din secretele pipeline-ului cu --env-var în Newman.

Secretele scapă de obicei pe trei căi: Initial value sincronizat, cereri cu valori scrise de mână și exporturi puse în git. Contramăsuri:

  • Current value doar: valoarea există numai local; Initial value rămâne gol sau cu un text ca completează local;
  • tipul secret: valoarea e mascată pe ecran (utile în demo-uri și capturi);
  • Postman Vault: secrete stocate local, criptate, citite cu {{vault:nume}} sau pm.vault.get(), care nu se sincronizează în cloud;
  • niciun secret în cerere: tokenul e {{token}}, niciodată textul lui; la fel în antetele copiate din cURL;
  • exporturi verificate: înainte de commit, cauți în JSON Bearer ey, password, apiKey;
  • CI: environment-ul din repository are doar baseUrl, iar secretele vin din variabilele protejate ale pipeline-ului:
BASH
newman run colectie.json -e staging.json --env-var "parola=$QA_PAROLA"

Și, important: chiar și credențialele de test se rotesc dacă au scăpat, pentru că mediile de test au adesea date reale copiate.

Ce urmărește intervievatorul: Întrebare de securitate operațională. Intervievatorul caută practici concrete, inclusiv în CI.

34 Senior

Cum previi rularea accidentală a unei colecții distructive (ștergeri, comenzi) pe mediul de producție?

Răspuns scurt: Mai multe straturi: environment de producție separat, fără credențiale de scriere; un pre-request la nivel de colecție care oprește execuția dacă baseUrl e de producție; colecții distructive separate; în CI, ținte fixe per job.

Un DELETE rulat din greșeală pe producție e un incident real, iar selectorul de environment e foarte ușor de ratat. Un singur strat de protecție nu e suficient.

1. Gardă în script. În pre-request-ul colecției distructive:

JavaScript
const url = pm.environment.get("baseUrl") || "";
if (/api\.firma\.ro/.test(url) && pm.environment.get("permiteProd") !== "da") {
    throw new Error("Colecția de teste NU rulează pe producție: " + url);
}

Un throw în pre-request oprește trimiterea cererii.

2. Credențiale. Environment-ul de producție, dacă există, folosește un cont doar de citire; tokenurile de scriere nu există local.

3. Separare. Smoke testele nedistructive (GET-uri) într-o colecție, fluxurile cu scriere în alta, care nu are environment de producție asociat.

4. Vizibil. Environment-ul de producție are un nume care sare în ochi și, în Postman, poate avea culoare/etichetă distinctă.

5. CI. Jobul de producție rulează doar colecția de smoke, cu environment fix, nu ales de om.

Ideea de fond: protecția trebuie să funcționeze și când omul greșește.

Ce urmărește intervievatorul: Întrebare senior despre risc. Se urmărește gândirea în straturi și conștientizarea că greșeala umană e inevitabilă.

35 Senior

Ce strategie de variabile și medii ai propune pentru o echipă cu 5 microservicii și 4 medii?

Răspuns scurt: Un environment pe mediu, cu câte un baseUrl pe serviciu și utilizatorii de test ai mediului; variabile de colecție pentru ce ține de serviciu; globale aproape deloc; secrete doar local sau în Vault; convenții de nume scrise și aplicate.

Fără o convenție, după câteva luni ai 30 de environment-uri, nume duplicate și nimeni nu știe care e bun.

O strategie care funcționează:

  • un environment pe mediu, nu pe serviciu: Local, Dev, Staging, Prod-readonly. Fiecare conține catalogUrl, comenziUrl, platiUrl etc., ca un flux care atinge mai multe servicii să meargă cu un singur mediu selectat;
  • o colecție pe serviciu, cu variabile de colecție pentru ce ține de el (ID-uri de test stabile, versiunea de API);
  • o colecție de fluxuri cross-serviciu, care folosește aceleași environment-uri;
  • nume consecvente: camelCase, sufix Url pentru adrese, prefix tmp pentru valori temporare de șters la final;
  • globale: doar dacă există un motiv clar;
  • secrete: Vault sau Current value; în CI, --env-var din secretele pipeline-ului;
  • sursa de adevăr: environment-urile fără secrete exportate în repository, ca CI-ul să folosească aceleași valori ca oamenii.

Convenția o scrii în descrierea workspace-ului și o verifici la review-ul pull request-urilor Postman.

Ce urmărește intervievatorul: Întrebare de design la nivel de echipă. Se apreciază argumentarea alegerii „environment pe mediu, nu pe serviciu”.

Autentificare și autorizare

36 Junior

Ce tipuri de autentificare oferă tabul Authorization din Postman și ce face concret fiecare cu cererea?

Răspuns scurt: No Auth, Inherit auth from parent, API Key (antet sau query), Bearer Token, Basic Auth, Digest, OAuth 1.0, OAuth 2.0 și altele (AWS Signature, NTLM). Fiecare adaugă automat antetul sau parametrul potrivit.

Tabul Authorization construiește partea de autentificare a cererii, ca să nu scrii antetele de mână:

  • No Auth: nu adaugă nimic;
  • Inherit auth from parent: folosește setarea folderului sau a colecției;
  • API Key: o cheie cu numele și valoarea alese, pusă în antet (X-API-Key) sau în query (?api_key=);
  • Bearer Token: Authorization: Bearer <token>;
  • Basic Auth: Authorization: Basic <base64(user:parolă)>;
  • Digest Auth: răspuns la provocarea serverului, fără parola în clar;
  • OAuth 2.0: obține tokenul printr-un flux (Authorization Code, Client Credentials, Password) și îl atașează;
  • AWS Signature, Hawk, NTLM, Akamai: semnături specifice.

Ce a generat Postman vezi în tabul Headers (antetele ascunse) și în Console. Avantajul față de un antet scris manual: autentificarea se poate moșteni de la colecție și se schimbă dintr-un singur loc.

Capcana: dacă pui și un antet Authorization manual în Headers, rezultatul depinde de ordinea aplicării și poate fi confuz. Folosește un singur mecanism.

Ce urmărește intervievatorul: Verifică familiaritatea cu instrumentul. Un răspuns bun explică și ce antet produce fiecare tip.

Eroarea, în practică:401 UnauthorizedMissing Authorization Header

37 Junior

Cum funcționează „Inherit auth from parent” și cum faci o cerere de login să nu trimită tokenul colecției?

Răspuns scurt: Cererea folosește autentificarea folderului sau a colecției. Pentru login, pui pe cerere (sau pe folderul Auth) No Auth, ca să nu trimită un token vechi, eventual expirat.

Când o cerere are Inherit auth from parent, Postman urcă în ierarhie: întâi folderul care o conține, apoi folderul părinte, apoi colecția. Prima setare diferită de „Inherit” se aplică.

Avantajul: setezi Bearer {{token}} o singură dată pe colecție, iar toate cererile îl folosesc. Când tokenul se schimbă, nu modifici 50 de cereri.

Excepțiile se setează explicit:

  • Login, înregistrare, resetare parolă: No Auth. Altfel cererea de login trimite tokenul vechi; unele servere îl ignoră, altele răspund 401 „token expirat” chiar înainte să verifice parola, și nu mai poți obține unul nou;
  • folderul Admin: Bearer cu {{tokenAdmin}};
  • cereri de test anonime („fără token → 401”): No Auth, altfel testul verifică de fapt un utilizator autentificat.

Când nu știi ce autentificare a plecat, tabul Authorization al cererii îți spune de la ce părinte o moștenește, iar Console îți arată antetul final.

Ce urmărește intervievatorul: Testează dacă știi să structurezi autentificarea pe colecție. Exemplul cu login-ul care trimite token vechi arată experiență practică.

Eroarea, în practică:Missing Authorization Header

38 Junior

API key în antet sau în query string: ce diferențe sunt și ce ai testa?

Răspuns scurt: Funcțional sunt echivalente, dar cheia din query ajunge în loguri, istoricul browserului și analytics, deci antetul e mai sigur. Testezi cheie lipsă, greșită, revocată și dacă serverul acceptă cheia din locul greșit.

Postman permite ambele variante din tabul Authorization → API Key, câmpul Add to.

În antet (X-API-Key: ...): nu apare în URL, deci nu ajunge în logurile serverelor web, proxy-uri, istoric sau antetul Referer. E varianta recomandată.

În query (?api_key=...): mai comodă pentru un link de test, dar cheia ajunge peste tot unde ajunge URL-ul. Unele API-uri o acceptă pentru compatibilitate.

Ce testezi:

  • fără cheie → 401 (de obicei), cu mesaj clar;
  • cheie greșită → 401 sau 403, după convenția API-ului, dar consecvent;
  • cheie revocată sau a altui client → refuzată;
  • cheia în locul nedocumentat (în query, deși documentația spune antet) → ideal refuzată, ca să nu încurajeze folosirea nesigură;
  • numele antetului e sensibil la majuscule? Antetele HTTP nu sunt, deci x-api-key trebuie să meargă;
  • cheia nu apare în corpul răspunsurilor de eroare.

Ca tester, mai verifici că documentația nu publică o cheie reală în exemple.

Ce urmărește intervievatorul: Combină cunoștințe de Postman cu securitate de bază. Răspunsul slab: „e același lucru”.

Eroarea, în practică:No API key found in requestInvalid authentication credentials

39 Junior

Ce trimite Postman la Basic Auth și de ce Basic Auth nu e sigur fără HTTPS?

Răspuns scurt: Antetul Authorization: Basic urmat de user:parolă codat în Base64. Base64 e doar codare, nu criptare, deci oricine interceptează cererea pe HTTP citește parola. Cu HTTPS, canalul e criptat.

La Basic Auth, Postman ia utilizatorul și parola, le unește cu două puncte și le codează în Base64:

ana@magazin.test:Parola123!  →  Authorization: Basic YW5hQG1hZ2F6aW4udGVzdDpQYXJvbGExMjMh

Base64 e o codare reversibilă, nu o criptare; oricine vede antetul îl decodează instantaneu (atob(...) în consolă). De aceea:

  • pe HTTP simplu, parola circulă practic în clar prin rețea;
  • pe HTTPS, conținutul e criptat în tranzit, deci Basic Auth e acceptabil pentru API-uri interne sau servicii simple;
  • parola se trimite la fiecare cerere, deci orice log care păstrează antetele o expune.

Ce testezi la un endpoint cu Basic Auth: fără antet → 401 cu antetul WWW-Authenticate: Basic realm="..."; parolă greșită → 401; utilizator inexistent → același răspuns ca la parolă greșită (să nu poți afla ce conturi există); endpointul nu e accesibil pe HTTP; după multe încercări greșite apare o limitare.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței codare/criptare. Mulți candidați cred că Base64 „ascunde” parola.

Eroarea, în practică:401 cu WWW-Authenticate: Basic

40 Junior

Cum automatizezi în Postman login-ul, ca tokenul să fie salvat și folosit de toate cererile?

Răspuns scurt: În Post-response-ul cererii de login citești tokenul din răspuns și îl salvezi cu pm.environment.set, doar dacă statusul e 200. Colecția are Bearer {{token}}, iar cererile moștenesc autentificarea.

Fluxul are două părți.

1. Cererea de login (cu No Auth) salvează tokenul:

JavaScript
pm.test("Login reușit", function () {
    pm.response.to.have.status(200);
});
if (pm.response.code === 200) {
    const j = pm.response.json();
    pm.environment.set("token", j.token);
    pm.environment.set("tokenExpira", Date.now() + j.expiresIn * 1000);
}

2. Colecția are Authorization → Bearer Token cu valoarea {{token}}, iar cererile sunt pe Inherit.

Detalii care contează:

  • salvezi doar la succes; altfel, la un login greșit, tokenul devine undefined, iar cererile pleacă cu Bearer undefined și primești 401 fără să înțelegi de ce;
  • verifici exact numele câmpului (token, accessToken, access_token); o greșeală aici dă același undefined;
  • salvezi și expirarea, ca să poți reîmprospăta automat;
  • tokenul stă în environment pentru că diferă pe mediu, și ajunge doar în Current value.

Pas următor firesc: un pre-request la nivel de colecție care face login singur dacă tokenul lipsește sau a expirat.

Ce urmărește intervievatorul: Întrebare practică standard. Intervievatorul urmărește detaliul „salvez doar la succes” și numele exact al câmpului.

Eroarea, în practică:401 Unauthorized401: jwt expired

41 Mid

Cum faci ca tokenul să se reîmprospăteze automat când expiră, fără să rulezi manual login-ul?

Răspuns scurt: Un pre-request la nivel de colecție verifică dacă tokenul lipsește sau expiră în curând și, dacă da, face login sau refresh cu pm.sendRequest, salvează noul token și abia apoi pleacă cererea.

Soluția stă în scriptul Pre-request al colecției, care rulează înaintea fiecărei cereri:

JavaScript
const expira = Number(pm.environment.get("tokenExpira") || 0);
if (!pm.environment.get("token") || Date.now() > expira - 30000) {
    pm.sendRequest({
        url: pm.environment.get("baseUrl") + "/auth/login",
        method: "POST",
        header: { "Content-Type": "application/json" },
        body: { mode: "raw", raw: JSON.stringify({
            email: pm.environment.get("email"),
            password: pm.environment.get("parola") }) }
    }, function (err, res) {
        if (err || res.code !== 200) { console.error("Login eșuat", err || res.code); return; }
        pm.environment.set("token", res.json().token);
        pm.environment.set("tokenExpira", Date.now() + res.json().expiresIn * 1000);
    });
}

Puncte importante:

  • marja de 30 de secunde evită un token care expiră chiar în timpul cererii;
  • Postman așteaptă terminarea pm.sendRequest înainte să trimită cererea principală;
  • cererea de login nu trebuie să declanșeze ea însăși scriptul la nesfârșit (pm.sendRequest nu rulează scripturile colecției, deci e sigur);
  • dacă API-ul are refresh token, folosești endpointul de refresh, iar login complet doar dacă refresh-ul e respins.

Ce urmărește intervievatorul: Întrebare clasică de nivel mediu. Se urmărește că știi unde se pune scriptul și că tratezi eșecul login-ului.

Eroarea, în practică:401: jwt expired

42 Mid

Cum configurezi OAuth 2.0 în Postman și ce grant type alegi pentru un test automat, fără browser?

Răspuns scurt: În Authorization → OAuth 2.0 completezi URL-urile, client id, secret și scope, apoi Get New Access Token. Pentru automatizare folosești Client Credentials (serviciu la serviciu) sau Password, dacă e permis; Authorization Code cere interacțiune în browser.

Postman are un asistent complet pentru OAuth 2.0: alegi Grant type, completezi Auth URL, Access Token URL, Client ID, Client Secret, Scope și Callback URL, apoi Get New Access Token. Tokenul primit e salvat și atașat automat ca Bearer.

Grant types:

  • Authorization Code (cu PKCE): deschide pagina de login în browser, iar Postman primește codul pe callback. Corect pentru aplicații cu utilizator, dar cere interacțiune;
  • Client Credentials: aplicația se autentifică cu id și secret, fără utilizator. Ideal pentru Newman și CI;
  • Password (Resource Owner): trimite direct utilizator și parolă; depreciat în OAuth 2.1, dar încă întâlnit în medii de test;
  • Implicit: depreciat.

În CI nu poți apăsa butoane, deci obții tokenul fie cu o cerere explicită POST /oauth/token (body x-www-form-urlencoded, grant_type=client_credentials), fie cu pm.sendRequest în pre-request.

Greșeli frecvente: body JSON în loc de form-urlencoded la endpointul de token (răspuns 400 sau 415), scope greșit (token valid, dar 403 pe endpoint), Callback URL neînregistrat la provider.

Ce urmărește intervievatorul: Verifică dacă știi OAuth practic, inclusiv limitarea în CI. Detaliul cu form-urlencoded la endpointul de token e un semn de experiență.

Eroarea, în practică:invalid_grant (OAuth 2.0)unsupported_grant_type (OAuth 2.0)

43 Mid

Cum verifici într-un test Postman conținutul unui JWT primit la login?

Răspuns scurt: Împarți tokenul după punct, decodezi a doua parte din Base64URL cu atob și JSON.parse, apoi verifici claim-uri precum sub, role și exp. Asta verifică conținutul, nu semnătura.

Un JWT are trei părți separate prin punct: antet, payload și semnătură. Payload-ul e JSON codat Base64URL, deci îl poți citi direct în test:

JavaScript
const token = pm.response.json().token;
const parti = token.split(".");
const b64 = parti[1].replace(/-/g, "+").replace(/_/g, "/");
const payload = JSON.parse(atob(b64));

pm.test("Tokenul e pentru Ana, cu rol customer", function () {
    pm.expect(parti).to.have.lengthOf(3);
    pm.expect(payload.email).to.equal("ana@magazin.test");
    pm.expect(payload.role).to.equal("customer");
    pm.expect(payload.exp * 1000).to.be.above(Date.now());
});

Ce mai merită verificat:

  • exp minus iat corespunde duratei documentate (de exemplu o oră);
  • payload-ul nu conține date sensibile (parolă, hash, CNP), pentru că oricine îl poate decoda;
  • algoritmul din antet nu e none.

Limită importantă: testul nu verifică semnătura. Asta o face serverul. Ce poți testa din Postman e că serverul respinge un token cu payload modificat (de exemplu role schimbat în admin) cu 401.

Ce urmărește intervievatorul: Combină decodare practică cu înțelegerea limitelor. Testul cu payload modificat e un plus apreciat.

Eroarea, în practică:jwt malformedinvalid signature

44 Mid

Cum organizezi în Postman testarea autorizării pentru trei roluri (anonim, client, admin) pe aceleași endpointuri?

Răspuns scurt: Un token pe rol în environment și o matrice de cazuri: fiecare endpoint rulat cu fiecare rol și statusul așteptat. Cel mai simplu: CSV cu rol, endpoint, metodă și status așteptat, rulat data-driven, sau foldere pe rol cu autentificare diferită.

Autorizarea se testează ca o matrice: endpointuri pe rânduri, roluri pe coloane, status așteptat în celule.

| Endpoint | Anonim | Client | Admin | |---|---|---|---| | GET /products | 200 | 200 | 200 | | GET /users | 401 | 403 | 200 | | POST /products | 401 | 403 | 201 |

În Postman ai două variante:

1. Foldere pe rol. Folderul „Anonim” cu No Auth, „Client” cu {{tokenClient}}, „Admin” cu {{tokenAdmin}}. Aceleași cereri duplicate, fiecare cu statusul așteptat. Simplu de citit, dar duplicare.

2. Data-driven. O singură cerere generică, un CSV cu coloanele rol,metoda,cale,status, iar pre-request-ul alege tokenul după rol:

JavaScript
const rol = pm.iterationData.get("rol");
pm.request.headers.upsert({ key: "Authorization",
    value: rol === "anonim" ? "" : "Bearer " + pm.environment.get("token_" + rol) });

Testul compară pm.response.code cu pm.iterationData.get("status"). Matricea devine documentație a drepturilor și se extinde adăugând rânduri.

Ce urmărește intervievatorul: Testează gândirea sistematică pentru autorizare. Se apreciază matricea explicită și soluția data-driven.

Eroarea, în practică:403 Forbidden

45 Senior

Ce teste de securitate de bază poți face cu Postman pe un API, fără unelte specializate?

Răspuns scurt: Acces fără token și cu token modificat, acces la resursele altui utilizator (IDOR), câmpuri trimise în plus (mass assignment), input-uri de injecție, metode nepermise, mesaje de eroare care dezvăluie detalii interne, limitare la încercări repetate.

Postman nu înlocuiește un test de penetrare, dar acoperă bine verificările de bază din OWASP API Top 10:

  • Autentificare: fără token, token expirat, token cu semnătură stricată, token cu payload modificat. Toate trebuie respinse cu 401;
  • IDOR / acces la obiectele altora: Ana cere comanda lui Mihai schimbând ID-ul din URL. Trebuie 403 sau 404, nu datele;
  • Mass assignment: la PATCH /users/me trimiți și "role": "admin" sau "balance": 9999. Câmpurile protejate trebuie ignorate sau refuzate;
  • Funcții de admin: un client apelează endpointuri de admin;
  • Injecție: ' OR 1=1--, <script> în câmpuri text; serverul nu trebuie să dea 500 și nici să întoarcă conținutul neescapat;
  • Limitare: zeci de login-uri greșite la rând trebuie să ducă la 429 sau blocare;
  • Informații scăpate: erorile 500 nu conțin stack trace, versiuni de framework sau interogări SQL; antetele nu dezvăluie versiuni (X-Powered-By);
  • Expunere de date: răspunsul nu conține câmpuri interne (hash de parolă, note interne).

Toate pot sta într-un folder „Securitate” rulat în CI, cu bug-urile găsite documentate.

Ce urmărește intervievatorul: Întrebare senior: se verifică dacă vezi testarea API dincolo de funcțional. Lista trebuie să fie concretă, cu rezultatul așteptat.

Eroarea, în practică:500 la un câmp prea lung (în loc de 422)

46 Senior

Un API cere ca fiecare cerere să fie semnată cu HMAC peste metodă, cale, timestamp și body. Cum o testezi în Postman?

Răspuns scurt: Un pre-request calculează semnătura cu CryptoJS.HmacSHA256 peste textul canonic (cu variabilele deja rezolvate), o pune în antet împreună cu timestamp-ul, apoi testezi că semnăturile greșite, vechi sau pe body modificat sunt respinse.

Postman include CryptoJS în sandbox, deci semnătura se calculează în pre-request:

JavaScript
const ts = Math.floor(Date.now() / 1000).toString();
const body = pm.variables.replaceIn(pm.request.body ? pm.request.body.raw || "" : "");
const cale = pm.request.url.getPathWithQuery();
const text = [pm.request.method, cale, ts, body].join("\n");
const sig = CryptoJS.HmacSHA256(text, pm.environment.get("secret")).toString(CryptoJS.enc.Hex);
pm.request.headers.upsert({ key: "X-Timestamp", value: ts });
pm.request.headers.upsert({ key: "X-Signature", value: sig });

Detalii care strică semnătura în practică: body-ul cu {{variabile}} nerezolvate (de aici replaceIn), calea cu sau fără query, spații sau ordinea cheilor diferită față de server și secretul codat diferit (text vs hex).

Testele negative sunt la fel de importante:

  • semnătură greșită → 401;
  • timestamp vechi de 10 minute → respins (protecție la replay);
  • aceeași semnătură trimisă de două ori → respinsă, dacă API-ul folosește nonce;
  • body modificat după semnare → respins.

O idee bună: ceri dezvoltatorilor un exemplu calculat (text canonic + semnătură) și îl folosești ca test pentru scriptul tău.

Ce urmărește intervievatorul: Întrebare senior practică, frecventă la API-uri de plăți. Se urmărește atenția la textul canonic și testele de replay.

Scripturi pre-request și post-response

47 Junior

Ce sunt scripturile Pre-request și Post-response în Postman și ce pui de obicei în fiecare?

Răspuns scurt: Cod JavaScript care rulează înainte, respectiv după cerere. În Pre-request pregătești date, antete, tokenuri și semnături; în Post-response scrii testele și salvezi valori din răspuns pentru cererile următoare.

Postman are un sandbox JavaScript cu obiectul global pm.

Pre-request (tabul Scripts → Pre-request) rulează înainte să plece cererea. Folosiri tipice:

  • generezi date: un email unic, o dată calculată, un ID de idempotență;
  • adaugi sau modifici antete cu pm.request.headers.upsert(...);
  • obții sau reîmprospătezi un token cu pm.sendRequest;
  • calculezi semnături (HMAC);
  • verifici precondiții (variabila există) și oprești rularea dacă lipsesc.

Post-response (fost tabul Tests) rulează după răspuns:

  • teste cu pm.test și pm.expect;
  • salvezi date din răspuns (token, id) în variabile;
  • decizi următoarea cerere în Runner cu pm.execution.setNextRequest;
  • scrii informații de diagnostic în consolă.

Ambele există pe trei niveluri: colecție, folder și cerere, și rulează în această ordine. Un throw sau o eroare de sintaxă în pre-request oprește trimiterea cererii, iar Console afișează „There was an error in evaluating the Pre-request Script”.

Ce urmărește intervievatorul: Verifică înțelegerea de bază a scripturilor și a scopului fiecăruia. Exemplele concrete contează mai mult decât definiția.

Eroarea, în practică:Error in evaluating the Pre-request ScriptError in evaluating the Test Script

48 Junior

Cum citești în script datele din răspuns: body JSON, text, antete, status și timp?

Răspuns scurt: pm.response.json() pentru JSON, pm.response.text() pentru text, pm.response.headers.get("Nume") pentru antete, pm.response.code și pm.response.status pentru status, pm.response.responseTime pentru timp.

Obiectul pm.response expune tot ce vezi în panoul de răspuns:

JavaScript
const j = pm.response.json();               // body parsat ca JSON
const t = pm.response.text();               // body ca text
const cod = pm.response.code;               // 200
const text = pm.response.status;            // "OK"
const ct = pm.response.headers.get("Content-Type");
const ms = pm.response.responseTime;        // milisecunde
const marime = pm.response.responseSize;
const sesiune = pm.cookies.get("session");

Câteva capcane:

  • pm.response.json() aruncă eroare dacă body-ul nu e JSON (o pagină HTML de eroare, un 204 gol): „JSONError: Unexpected token '<' at 1:1”. Verifici întâi Content-Type sau statusul;
  • apelul repetat al json() parsează din nou; îl salvezi într-o constantă;
  • headers.get nu ține cont de majuscule la numele antetului;
  • pentru XML ai xml2Json(pm.response.text()).

Pentru cerere ai obiectul simetric pm.request: pm.request.url, pm.request.method, pm.request.headers, pm.request.body. Util în scripturile de colecție care tratează diferit cererile.

Ce urmărește intervievatorul: Întrebare de bază despre API-ul pm. Se urmărește și cunoașterea erorii la un body care nu e JSON.

Eroarea, în practică:JSONError: Unexpected token '<' at 1:1Unexpected token '<' ... is not valid JSON

49 Junior

Cum adaugi sau modifici un antet al cererii dintr-un script Pre-request?

Răspuns scurt: Cu pm.request.headers.add pentru un antet nou, upsert pentru a-l adăuga sau înlocui și remove pentru a-l șterge. Modificarea se aplică doar cererii care pleacă, nu se salvează în editor.

Obiectul pm.request.headers e o listă de antete pe care o poți modifica înainte de trimitere:

JavaScript
// adaugă (poate crea duplicat dacă există deja)
pm.request.headers.add({ key: "X-Request-Id", value: pm.variables.replaceIn("{{$guid}}") });

// adaugă sau înlocuiește
pm.request.headers.upsert({ key: "Accept-Language", value: "ro-RO" });

// șterge
pm.request.headers.remove("X-Debug");

Folosiri tipice: un ID de corelare pe fiecare cerere (bun pentru căutarea în logurile serverului), un antet de versiune de API, o semnătură sau un token calculat.

De reținut:

  • modificarea afectează doar execuția curentă; în tabul Headers nu apare, deci verifici în Console;
  • add pe un antet existent poate trimite două valori, iar serverul o alege pe una sau le concatenează; upsert e mai sigur;
  • pus în pre-request-ul colecției, antetul se aplică tuturor cererilor;
  • un antet scris greșit (pm.request.header.add) dă „TypeError: Cannot read properties of undefined”, iar cererea nu mai pleacă.

Ce urmărește intervievatorul: Verifică dacă știi să manipulezi cererea din cod. Diferența add/upsert e un detaliu practic bun.

50 Junior

Cum folosești consola Postman pentru a depana un script care nu face ce trebuie?

Răspuns scurt: Pui console.log cu valorile intermediare (răspunsul, variabila citită, rezultatul unui calcul), rulezi cererea și citești în Console. Erorile de script apar și ele acolo, cu mesajul și scriptul în care s-au produs.

Depanarea în sandbox-ul Postman se face aproape numai cu consola:

JavaScript
const j = pm.response.json();
console.log("status", pm.response.code, "items", j.items && j.items.length);
console.log("token salvat:", pm.environment.get("token"));
console.warn("preț neașteptat", j.price);
console.error("lipsește câmpul id");

Ce vezi în Console:

  • mesajele tale, cu nivelul (log, warn, error) și obiectele expandabile;
  • erorile scripturilor: „There was an error in evaluating the Post-response Script: TypeError: Cannot read properties of undefined (reading 'length')”;
  • cererea și răspunsul complet, ca să verifici că valoarea folosită în script e cea reală.

Tehnica bună: când un test pică inexplicabil, loghezi exact valorile comparate, cu JSON.stringify(x) pentru obiecte, ca să vezi tipul ("89" vs 89) și spațiile. Când ai terminat, scoți logurile zgomotoase, ca rapoartele Newman să rămână lizibile; cele utile la diagnostic în CI le poți păstra.

Ce urmărește intervievatorul: Se verifică o metodă de depanare. Candidații care depanează prin încercări fără loguri pierd mult timp.

Eroarea, în practică:Error in evaluating the Pre-request ScriptError in evaluating the Test Script

51 Junior

Cum transmiți date de la o cerere la alta, de exemplu ID-ul unei comenzi create?

Răspuns scurt: În Post-response-ul cererii care creează comanda citești ID-ul și îl salvezi într-o variabilă de colecție sau environment; cererile următoare îl folosesc ca {{orderId}} în URL sau body.

Acesta e mecanismul de bază pentru fluxuri:

JavaScript
// POST /orders → Post-response
pm.test("Comanda a fost creată", function () {
    pm.response.to.have.status(201);
});
if (pm.response.code === 201) {
    pm.collectionVariables.set("orderId", pm.response.json().id);
}

Apoi GET {{baseUrl}}/orders/{{orderId}} și POST {{baseUrl}}/orders/{{orderId}}/cancel folosesc valoarea salvată.

Alegerea scope-ului:

  • variabilă de colecție: bună pentru date create în flux; nu depinde de mediu;
  • environment: dacă vrei s-o vezi lângă celelalte setări ale mediului;
  • locală (pm.variables.set): doar dacă e folosită în aceeași rulare de Runner, nu și la trimiterea manuală a cererii următoare.

Greșeli frecvente: numele câmpului greșit (orderId în loc de id) salvează undefined; salvarea făcută și când crearea eșuează, deci pașii următori lucrează pe o comandă veche; cereri rulate manual în altă ordine. Un pre-request în cererile dependente care verifică existența variabilei face eroarea clară.

Ce urmărește intervievatorul: Întrebare practică de bază pentru fluxuri. Se urmărește condiționarea salvării de succesul cererii.

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

52 Mid

Cum funcționează pm.sendRequest și când îl folosești în locul unei cereri separate din colecție?

Răspuns scurt: Trimite o cerere suplimentară din script și primește răspunsul într-un callback (sau cu await în versiunile noi). Îl folosești pentru pași auxiliari: obținerea unui token, crearea unor date de test, verificarea unei stări după cerere.

pm.sendRequest trimite o cerere HTTP din interiorul unui script:

JavaScript
pm.sendRequest({
    url: pm.environment.get("baseUrl") + "/products/7",
    method: "GET"
}, function (err, res) {
    if (err) { console.error(err); return; }
    pm.collectionVariables.set("pretInitial", res.json().price);
});

Versiunile recente acceptă și const res = await pm.sendRequest(...).

Când îl preferi unei cereri din colecție:

  • pași auxiliari care nu sunt subiectul testului: login, crearea unui produs de test, curățenie;
  • verificări după acțiune: după DELETE /cart/items/7, în Post-response verifici cu un GET că produsul chiar a dispărut;
  • independență: cererea își pregătește singură datele, fără să depindă de ordinea din colecție.

Când nu îl folosești: când pasul e chiar ce testezi. Cererile din pm.sendRequest nu apar ca cereri separate în rapoartele Runner/Newman și nu rulează scripturile colecției, deci un eșec al lor e mai greu de observat. De aceea tratezi explicit err și statusul.

Ce urmărește intervievatorul: Testează folosirea corectă a cererilor auxiliare. Răspunsul bun discută și dezavantajul vizibilității în rapoarte.

Eroarea, în practică:Cannot read properties of null (reading 'json')

53 Mid

Ce scrii în scripturile la nivel de colecție și ce lași pe cereri?

Răspuns scurt: La colecție pui ce se aplică tuturor: token reîmprospătat, antete comune, verificări generale (fără 5xx, timp sub prag, Content-Type JSON). Pe cerere rămân testele specifice endpointului și salvarea datelor proprii.

Scripturile de colecție rulează pentru fiecare cerere, înaintea celor de folder și de cerere. Sunt locul potrivit pentru:

Pre-request colecție:

  • login automat sau refresh de token;
  • antete comune (ID de corelare, limbă);
  • gărzi de mediu (nu rulăm pe producție).

Post-response colecție:

JavaScript
pm.test("[global] fără eroare de server", function () {
    pm.expect(pm.response.code).to.be.below(500);
});
pm.test("[global] răspuns sub 2s", function () {
    pm.expect(pm.response.responseTime).to.be.below(2000);
});

Pe cerere rămân: statusul exact, câmpurile și valorile specifice, salvarea ID-urilor.

Atenție la excepții: o verificare globală „Content-Type e JSON” pică la endpointul care descarcă un CSV, iar „status 2xx” pică la toate testele negative. Fie formulezi verificările globale ca să fie adevărate pentru toate cererile, fie le condiționezi (if (pm.info.requestName.startsWith("NEG")) return;). Prefixul [global] în nume ajută la citirea rapoartelor.

Ce urmărește intervievatorul: Se verifică designul de suită: evitarea duplicării fără a crea teste globale false. Excepțiile menționate fac diferența.

54 Mid

Ce librării poți folosi în sandbox-ul Postman și cum le încarci?

Răspuns scurt: Câteva sunt disponibile prin require: lodash, crypto-js, moment, ajv, chai, cheerio, uuid, xml2js, csv-parse și modulele Node buffer, url, util. Nu poți instala pachete npm arbitrare direct; pentru cod propriu reutilizabil există Package Library.

Sandbox-ul Postman nu e un Node.js complet, dar include o listă de librării, încărcate cu require:

JavaScript
const _ = require("lodash");
const moment = require("moment");
const Ajv = require("ajv");
const cheerio = require("cheerio");
const { v4: uuid } = require("uuid");

Utile în practică:

  • lodash: _.sortBy, _.isEqual, _.get pe obiecte adânci;
  • crypto-js (și globală CryptoJS): hash-uri, HMAC, Base64;
  • moment: date formatate sau calculate;
  • ajv: validare JSON Schema (preferat față de tv4, depreciat);
  • cheerio: căutare în HTML;
  • xml2Json (globală): XML în obiect.

Ce nu merge: require("axios"), fs sau orice pachet care nu e în listă. Mesajul tipic e o eroare că modulul nu e găsit. Variantele: codul reutilizabil propriu în Package Library a echipei (pm.require("@echipa/utilitare")), o funcție salvată în variabilă și evaluată (practică veche, riscantă) sau mutarea logicii complicate într-un test în cod.

Ce urmărește intervievatorul: Testează limitele sandbox-ului. Un candidat bun știe ce nu poate face Postman și când trebuie altă unealtă.

Eroarea, în practică:Cannot find module 'axios'

55 Mid

De ce un test scris într-un callback de pm.sendRequest sau setTimeout poate să nu apară sau să treacă fals?

Răspuns scurt: Pentru că rulează asincron. Postman așteaptă callback-urile înregistrate, dar un pm.test pus greșit (după un return, într-o promisiune neașteptată) poate rula după raportare sau deloc, iar o aserțiune în afara lui pm.test nu produce test.

Codul asincron e cea mai frecventă sursă de teste „fantomă”.

Situații tipice:

  • pm.expect folosit în afara unui pm.test: dacă pică, aruncă o eroare de script, nu un test eșuat clar;
  • un pm.test fără nicio aserțiune trece mereu;
  • o promisiune creată și neașteptată (fetchCeva().then(...) fără await): testul din then poate rula după ce Postman a terminat scriptul;
  • un return timpuriu înainte de test, când nu există date: nu pică nimic, doar lipsește un test.

Variante corecte:

JavaScript
pm.sendRequest(url, function (err, res) {
    pm.test("Produsul există după creare", function () {
        pm.expect(err).to.be.null;
        pm.expect(res.code).to.equal(200);
    });
});

sau, în versiunile noi, const res = await pm.sendRequest(url); urmat de test.

În plus, în rapoarte verifici numărul de teste: dacă într-o zi o cerere are 3 teste în loc de 5, înseamnă că un bloc nu a mai rulat. Un test care nu poate pica e mai periculos decât lipsa testului.

Ce urmărește intervievatorul: Întrebare de nivel mediu despre corectitudinea testelor. Se urmărește conștientizarea testelor care trec fals.

Eroarea, în practică:Testul trece mereu (pm.expect fără aserțiune)

56 Mid

Cum folosești pm.info și pm.execution în scripturi și ce poți face cu ele?

Răspuns scurt: pm.info dă contextul: numele cererii, iterația curentă, numărul de iterații, tipul scriptului. pm.execution controlează rularea: setNextRequest pentru ordinea în Runner, skipRequest pentru a sări cererea curentă și location pentru calea în colecție.

pm.info spune unde te afli:

  • pm.info.requestName, pm.info.requestId;
  • pm.info.iteration (de la 0) și pm.info.iterationCount;
  • pm.info.eventName: prerequest sau test.

pm.execution controlează execuția:

  • pm.execution.setNextRequest("Nume"): în Runner/Newman, următoarea cerere va fi cea cu numele dat; null oprește rularea;
  • pm.execution.skipRequest(): în pre-request, cererea curentă nu mai pleacă (util când o precondiție nu e îndeplinită);
  • pm.execution.location: calea cererii în colecție (folderele), utilă în scripturile de colecție.

Exemple practice:

JavaScript
// script de colecție: testele de performanță doar pe folderul Catalog
if (pm.execution.location.includes("Catalog")) {
    pm.test("sub 500 ms", () => pm.expect(pm.response.responseTime).to.be.below(500));
}
// prima iterație face curățenie
if (pm.info.iteration === 0) { pm.collectionVariables.unset("orderId"); }

Atenție: setNextRequest nu are efect la trimiterea manuală a unei cereri, doar în Runner și Newman.

Ce urmărește intervievatorul: Verifică cunoașterea API-ului de control al rulării. Mențiunea că setNextRequest merge doar în Runner e importantă.

57 Senior

Scripturile din colecția echipei au ajuns la sute de linii copiate între cereri. Cum le faci reutilizabile și întreținute?

Răspuns scurt: Muți codul comun în scripturile de colecție sau folder, extragi funcțiile într-o bibliotecă de pachete a echipei (Package Library) încărcată cu pm.require, păstrezi pe cereri doar specificul și pui review pe schimbările de scripturi.

Scripturile copiate au aceeași problemă ca orice cod duplicat: o regulă se schimbă și o actualizezi în 40 de locuri, uitând 3.

Pași de refactorizare:

1. Ce e comun tuturor urcă în scriptul colecției sau al folderului: verificări generale, login automat, antete.

2. Funcțiile parametrizate (validare de schemă pentru o resursă, verificarea paginării, extragerea unui ID) merg într-o bibliotecă:

JavaScript
// Package Library: @magazin/verificari
module.exports = {
    paginare(j, limit) {
        pm.expect(j.items.length).to.be.at.most(limit);
        pm.expect(j).to.have.property("totalPages");
    }
};
// pe cerere
const v = pm.require("@magazin/verificari");
pm.test("Paginare corectă", () => v.paginare(pm.response.json(), 5));

3. Varianta veche, încă des întâlnită: funcții puse ca text într-o variabilă de colecție și rulate cu eval. Funcționează, dar e greu de citit și de depanat; merită migrată.

4. Convenții: nume de teste consecvente, mesaje în aserțiuni, fără loguri de depanare uitate.

5. Proces: schimbările de scripturi trec prin pull request, iar colecția rulează în CI înainte de merge. Dacă logica devine foarte complexă, e semn că testele respective aparțin într-un framework de cod.

Ce urmărește intervievatorul: Întrebare senior despre mentenanța testelor. Se apreciază și recunoașterea limitei de la care Postman nu mai e unealta potrivită.

58 Senior

Cum validezi că un API respectă paginarea corect pe toate paginile, nu doar pe prima?

Răspuns scurt: Un flux în Runner care pornește de la pagina 1, citește totalPages și X-Total-Count, parcurge paginile cu setNextRequest, adună ID-urile și la final verifică numărul total, lipsa duplicatelor și ultima pagină parțială.

Bug-urile de paginare apar rar pe prima pagină; de obicei ai elemente duplicate între pagini, elemente lipsă sau o ultimă pagină greșită.

Abordarea în Postman: o singură cerere GET {{baseUrl}}/products?page={{pagina}}&limit=10, rulată în buclă în Runner.

JavaScript
// Post-response
const j = pm.response.json();
const ids = JSON.parse(pm.collectionVariables.get("ids") || "[]");
ids.push(...j.items.map(p => p.id));
pm.collectionVariables.set("ids", JSON.stringify(ids));

const pagina = Number(pm.collectionVariables.get("pagina"));
if (pagina < j.totalPages) {
    pm.collectionVariables.set("pagina", pagina + 1);
    pm.execution.setNextRequest(pm.info.requestName);
} else {
    pm.test("Toate elementele, fără duplicate", function () {
        const total = Number(pm.response.headers.get("X-Total-Count"));
        pm.expect(ids.length).to.equal(total);
        pm.expect(new Set(ids).size).to.equal(ids.length);
    });
}

Mai verifici: pagina de după ultima întoarce listă goală (nu eroare), limit peste maxim e refuzat sau plafonat, sortarea e stabilă (fără ea, paginarea pe date egale poate amesteca elementele). O gardă pe numărul maxim de pagini evită o buclă infinită dacă totalPages e greșit.

Ce urmărește intervievatorul: Întrebare senior care combină scripturi, Runner și gândire de test. Garda împotriva buclei infinite e un semn de maturitate.

Eroarea, în practică:Runner-ul rulează la nesfârșit (buclă)

Teste și aserțiuni

Exersează capitolul cu exerciții reale: Curs Postman →
59 Junior

Cum arată un test în Postman și ce rol au pm.test și pm.expect?

Răspuns scurt: pm.test(nume, funcție) definește un test cu nume, afișat în Test Results; în funcție, pm.expect face aserțiunile în stil Chai. Dacă o aserțiune aruncă eroare, testul e marcat ca eșuat, iar celelalte teste rulează în continuare.

Structura e mereu aceeași:

JavaScript
pm.test("Produsul 7 are numele și prețul corecte", function () {
    const j = pm.response.json();
    pm.expect(j.name).to.equal("Mouse wireless");
    pm.expect(j.price).to.equal(89);
});
  • pm.test primește un nume, care apare în Test Results și în rapoartele Newman, și o funcție;
  • pm.expect e expect din Chai: to.equal, to.eql, to.include, to.be.above, to.have.property etc.;
  • dacă o aserțiune pică, restul funcției nu mai rulează, iar testul apare roșu cu mesajul Chai („expected 79 to equal 89”);
  • testele sunt independente: unul eșuat nu le oprește pe celelalte.

Bune practici de la început:

  • numele descrie comportamentul, nu implementarea („Prețul e număr pozitiv”, nu „test 3”);
  • un test, o idee: mai multe aserțiuni legate între ele sunt în regulă, dar nu amesteci statusul cu zece câmpuri diferite;
  • mesaj în aserțiune pentru valori greu de înțeles: pm.expect(j.stock, "stoc produs 12").to.be.above(0).

Ce urmărește intervievatorul: Verifică baza scrierii testelor. Intervievatorul se uită la calitatea numelor și la gruparea aserțiunilor.

Eroarea, în practică:AssertionError în afara lui pm.testInvalid Chai property: equalTo

60 Junior

Ce diferență e între pm.response.to.have.status(200) și pm.expect(pm.response.code).to.equal(200)?

Răspuns scurt: Verifică același lucru. Prima e o aserțiune specifică Postman, cu mesaj clar „expected response to have status code 200 but got 404”; a doua e Chai generic, cu mesajul „expected 404 to equal 200”. Pentru mai multe coduri acceptate folosești oneOf.

Postman extinde Chai cu aserțiuni pe răspuns, citite natural:

JavaScript
pm.response.to.have.status(200);
pm.response.to.have.status("Created");          // după text
pm.response.to.have.header("Content-Type");
pm.response.to.have.jsonBody("items");
pm.response.to.be.ok;                           // 2xx
pm.response.to.be.json;

Varianta generică:

JavaScript
pm.expect(pm.response.code).to.equal(200);
pm.expect(pm.response.code).to.be.oneOf([200, 204]);

Diferențele practice:

  • mesajul la eșec: forma Postman spune explicit că e vorba de status („expected response to have status code 201 but got 200”), mai ușor de citit în raportul Newman;
  • flexibilitate: forma generică permite oneOf, below(500), comparații cu variabile;
  • to.be.ok acceptă orice 2xx; e util la verificări globale, dar pe cerere preferi statusul exact, pentru că un 200 în loc de 201 poate fi chiar bug-ul.

Ambele variante sunt corecte; contează să alegi una consecvent în colecție.

Ce urmărește intervievatorul: Întrebare simplă care arată dacă știi API-ul de aserțiuni. Un plus: argumentul pentru status exact în loc de to.be.ok.

Eroarea, în practică:expected response to have status code 200expected 404 to equal 200

61 Junior

De ce testul pm.expect(j.items).to.equal([1, 2]) pică deși valorile arată identic și cum îl scrii corect?

Răspuns scurt: equal compară cu === referința, iar două array-uri sau obiecte diferite nu sunt niciodată identice ca referință. Pentru conținut folosești eql (deep equal) sau to.deep.equal.

În JavaScript, [1, 2] === [1, 2] e false: sunt două obiecte diferite în memorie. Chai equal folosește exact această comparație strictă, deci mesajul de eroare pare absurd:

AssertionError: expected [ 1, 2 ] to equal [ 1, 2 ]

Pentru compararea conținutului:

JavaScript
pm.expect(j.items).to.eql([1, 2]);           // deep equal
pm.expect(j.user).to.deep.equal({ id: 1, role: "customer" });
pm.expect(j.user).to.include({ role: "customer" });   // doar unele chei
pm.expect(j.tags).to.have.members(["nou", "promo"]); // ordinea nu contează

Când alegi ce:

  • equal pentru valori simple (numere, șiruri, true);
  • eql când vrei obiectul sau lista exact, cu toate cheile;
  • include când obiectul are și alte câmpuri care nu te interesează sau se schimbă (date, ID-uri generate);
  • members / include.members pentru liste în care ordinea nu e garantată.

Capcană: eql pe un obiect întreg face testul fragil. Orice câmp nou adăugat în API îl pică, deși nu e un bug.

Ce urmărește intervievatorul: Întrebare clasică despre egalitatea în JavaScript. Se urmărește și alegerea între eql și include.

Eroarea, în practică:expected {...} to equal {...} (obiecte identice)

62 Junior

Cum testezi că un răspuns cu o listă de produse are structura corectă, fără să depinzi de numărul exact de elemente?

Răspuns scurt: Verifici că items e array, că are cel mult limit elemente, apoi parcurgi elementele și verifici pentru fiecare câmpurile obligatorii și tipurile. Pentru structură completă folosești o schemă JSON.

Numărul exact de produse se schimbă când cineva adaugă date de test, deci un test pe lengthOf(30) pică fără motiv. Verifici proprietățile care trebuie să fie mereu adevărate:

JavaScript
const j = pm.response.json();

pm.test("items e o listă, cel mult limit elemente", function () {
    pm.expect(j.items).to.be.an("array").that.is.not.empty;
    pm.expect(j.items.length).to.be.at.most(10);
});

pm.test("Fiecare produs are id, nume și preț valid", function () {
    j.items.forEach(function (p, i) {
        pm.expect(p, "produsul " + i).to.include.keys("id", "name", "price");
        pm.expect(p.price, "preț produs " + p.id).to.be.a("number").and.above(0);
    });
});

Detalii importante:

  • mesajul cu indexul sau ID-ul arată care element a picat; fără el, raportul spune doar „expected -5 to be above 0”;
  • un forEach pe o listă goală nu verifică nimic, deci ai și testul „not empty”;
  • lengthOf exact se folosește doar când e garantat (de exemplu limit=5 pe un catalog cu 30 de produse).

Ce urmărește intervievatorul: Verifică dacă scrii teste robuste la schimbarea datelor. Mesajul per element e un detaliu de calitate.

Eroarea, în practică:forEach is not a functionexpected [ Array(5) ] to have a length of 10

63 Junior

Cum testezi valorile din antetele de răspuns, de exemplu Content-Type și Location?

Răspuns scurt: Cu pm.response.to.have.header("Nume") pentru existență și pm.response.headers.get("Nume") pentru valoare. Pentru Content-Type folosești include, pentru că valoarea conține și charset; pentru Location, match pe model.

Antetele se testează la fel de serios ca body-ul, pentru că clienții depind de ele.

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

pm.test("Location indică produsul nou", function () {
    const loc = pm.response.headers.get("Location");
    pm.expect(loc).to.match(/\/products\/\d+$/);
    pm.expect(loc).to.include(String(pm.response.json().id));
});

De ce include la Content-Type: valoarea reală e de obicei application/json; charset=utf-8, deci to.equal("application/json") pică.

Antete care merită verificate:

  • Location după 201 și la redirecționări;
  • Retry-After la 429 și 503;
  • X-Total-Count sau Link la paginare;
  • Cache-Control pe date personale (no-store);
  • WWW-Authenticate la 401;
  • antetele de securitate (Strict-Transport-Security, X-Content-Type-Options);
  • lipsa antetelor care dezvăluie tehnologia (X-Powered-By).

Numele antetelor nu țin cont de majuscule, deci headers.get("content-type") merge la fel.

Ce urmărește intervievatorul: Întrebare practică. Capcana cu charset în Content-Type e foarte frecventă.

Eroarea, în practică:expected 'application/json; charset=utf-8' to equalexpected response to have header with key

64 Junior

Cum scrii un test pentru un răspuns de eroare, de exemplu 404 sau 422, și ce verifici în afară de status?

Răspuns scurt: Verifici statusul exact, Content-Type JSON, structura erorii (cod, mesaj, detalii pe câmp), că mesajul e util și că nu scapă detalii interne precum stack trace sau SQL.

Un test negativ bun verifică tot contractul erorii, nu doar codul:

JavaScript
const j = pm.response.json();

pm.test("422 cu detalii pe câmpul email", function () {
    pm.response.to.have.status(422);
    pm.expect(j.error).to.equal("validation_error");
    pm.expect(j.details).to.be.an("array");
    const email = j.details.find(d => d.field === "email");
    pm.expect(email, "eroare pentru email").to.exist;
});

pm.test("Fără detalii interne", function () {
    const t = pm.response.text();
    pm.expect(t).to.not.match(/stack|at Object\.|SQL|Exception/i);
});

Ce mai contează:

  • formatul consecvent: toate erorile API-ului au aceeași structură, deci clientul le tratează uniform;
  • mesajul: spune ce e greșit („email invalid”), fără să dezvăluie prea mult („utilizatorul nu există” la login ajută un atacator);
  • Content-Type: multe servere întorc o pagină HTML la 404, ceea ce strică clientul;
  • toate câmpurile greșite deodată: trimiți două câmpuri invalide și verifici că apar ambele.

Ce urmărește intervievatorul: Testează gândirea pe cazuri negative, la nivel de contract. Verificarea scurgerilor de informații e un plus.

Eroarea, în practică:404 Not Foundexpected 404 to equal 200

65 Junior

Cum testezi timpul de răspuns în Postman și de ce un test cu prag fix poate fi problematic?

Răspuns scurt: pm.expect(pm.response.responseTime).to.be.below(prag). Problema: timpul variază cu rețeaua, încărcarea și cache-ul, deci un prag strâns dă eșecuri aleatoare. Folosești praguri generoase și le tratezi ca semnal, nu ca test de performanță.

Testul e simplu:

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

De ce e delicat:

  • timpul măsurat include rețeaua dintre tine și server; din CI-ul din altă regiune e alt timp decât de pe laptop;
  • prima cerere după o pauză e mai lentă (conexiune nouă, cache rece);
  • serverele de test sunt adesea mai slabe și partajate;
  • o singură măsurătoare nu spune nimic statistic.

Ce faci în practică:

  • praguri generoase, care prind doar degradările mari (de exemplu 2 secunde pe un endpoint care răspunde în 200 ms);
  • praguri diferite pe tipuri de endpointuri (raport vs detaliu produs);
  • un test separat, cu nume clar, ca să știi că eșecul e de timp, nu funcțional;
  • măsurare repetată pentru decizii (Runner cu mai multe iterații, apoi media sau percentila).

Pentru performanță reală (sarcină, concurență, percentile) folosești Performance testing din Postman sau unelte dedicate precum k6 și JMeter.

Ce urmărește intervievatorul: Verifică dacă înțelegi limitele testului de timp. Răspunsul slab: „pun 200 ms și gata”.

Eroarea, în practică:expected 1223 to be below 1000 (responseTime)

66 Mid

Cum validezi un răspuns contra unei scheme JSON în Postman și ce avantaj are față de verificarea câmp cu câmp?

Răspuns scurt: Definești schema (tipuri, câmpuri obligatorii, valori permise) și folosești pm.response.to.have.jsonSchema(schema) sau ajv. Schema verifică întreaga structură dintr-o dată, inclusiv câmpuri lipsă și tipuri greșite pe toate elementele.

Verificarea câmp cu câmp acoperă ce îți amintești să verifici; schema acoperă tot contractul.

JavaScript
const schema = {
    type: "object",
    required: ["id", "name", "price", "currency"],
    properties: {
        id: { type: "integer" },
        name: { type: "string", minLength: 1 },
        price: { type: "number", exclusiveMinimum: 0 },
        currency: { enum: ["RON"] },
        stock: { type: "integer", minimum: 0 }
    },
    additionalProperties: false
};
pm.test("Produsul respectă schema", function () {
    pm.response.to.have.jsonSchema(schema);
});

Avantaje:

  • prinde câmpuri lipsă, tipuri greșite ("89" în loc de 89) și valori în afara listei;
  • cu additionalProperties: false prinde și câmpurile apărute în plus (de exemplu un câmp intern scăpat);
  • schema se refolosește: o pui într-o variabilă de colecție sau o iei din specificația OpenAPI.

Mesajul la eșec indică problema: „data should have required property 'currency'”. Atenție: additionalProperties: false face testul strict; e util pentru date sensibile, dar pică la orice câmp nou adăugat legitim, deci decizia se ia cu echipa.

Ce urmărește intervievatorul: Întrebare de nivel mediu. Discuția despre additionalProperties arată că înțelegi compromisul strict/flexibil.

Eroarea, în practică:expected data to satisfy schemaexpected 89 to be a string

67 Mid

Cum testezi că filtrarea și sortarea unui endpoint de listă funcționează corect pe toate elementele întoarse?

Răspuns scurt: Pentru filtru verifici cu every că fiecare element respectă condiția (categorie, interval de preț). Pentru sortare compari lista primită cu o copie sortată în script, pe câmpul cerut, în direcția cerută.

Un test bun verifică regula pe toate elementele, nu doar pe primul.

JavaScript
const items = pm.response.json().items;

pm.test("Toate produsele sunt în categoria cerută și în interval", function () {
    pm.expect(items).to.not.be.empty;
    items.forEach(function (p) {
        pm.expect(p.category, "produs " + p.id).to.equal("periferice");
        pm.expect(p.price, "preț " + p.id).to.be.within(50, 200);
    });
});

pm.test("Sortate descrescător după preț", function () {
    const preturi = items.map(p => p.price);
    const sortate = [...preturi].sort((a, b) => b - a);
    pm.expect(preturi).to.eql(sortate);
});

Detalii care fac diferența:

  • lista nevidă: pe o listă goală, orice condiție „pe toate” trece;
  • limitele: minPrice=89 include produsul de 89? Documentația decide, testul verifică;
  • sortare numerică: sort() fără funcție compară text, deci 100 ajunge înaintea lui 89;
  • combinații: filtrul plus sortarea plus paginarea, pentru că bug-urile apar adesea doar împreună;
  • parametri invalizi: sort=nimic sau minPrice=abc trebuie să dea 400, nu să fie ignorați în tăcere.

Ce urmărește intervievatorul: Testează rigoarea testelor pe liste. Capcana sort() fără comparator e un detaliu de JavaScript des întâlnit.

Eroarea, în practică:expected 3499 to be below 1000expected [] not to be empty

68 Mid

Ce înseamnă un test „verde fals” în Postman și ce exemple ai întâlnit?

Răspuns scurt: Un test care trece deși comportamentul e greșit: aserțiune lipsă, forEach pe listă goală, comparație cu o variabilă undefined, test pe o valoare rămasă din rularea trecută, try/catch care înghite eroarea.

Testele care nu pot pica sunt mai periculoase decât lipsa testelor, pentru că dau încredere falsă. Exemple tipice în Postman:

  • fără aserțiune: pm.test("preț corect", function () { j.price > 0; });. Expresia nu face nimic, testul e verde;
  • listă goală: items.forEach(...) pe [] nu verifică nimic;
  • comparație cu undefined: pm.expect(j.total).to.equal(pm.variables.get("totalAsteptat")), iar ambele sunt undefined pentru că numele câmpului și al variabilei sunt greșite;
  • date rămase: testul citește orderId din rularea de ieri;
  • try/catch: un try { ... } catch (e) {} în test înghite eșecul aserțiunii;
  • condiție care sare testul: if (pm.response.code === 200) { pm.test(...) }. Când răspunsul e 500, testul pur și simplu nu există;
  • aserțiuni Chai incomplete: pm.expect(x).to.be.true scris pm.expect(x).to.be.ture poate trece neobservat în unele versiuni.

Cum le prinzi: rulezi o dată testul împotriva unui răspuns greșit (schimbi valoarea așteptată) și verifici că pică. E practica „vezi testul roșu înainte să-l crezi verde”.

Ce urmărește intervievatorul: Verifică maturitatea în scrierea testelor. Intervievatorul caută exemple concrete trăite, nu teorie.

Eroarea, în practică:Testul trece mereu (pm.expect fără aserțiune)

69 Mid

Cum verifici în Postman un calcul de business, de exemplu totalul unei comenzi cu reducere?

Răspuns scurt: Calculezi în script valoarea așteptată din datele cunoscute (prețuri, cantități, regula cuponului) și o compari cu totalul întors de API, cu atenție la rotunjiri. Nu copiezi valoarea din răspuns în așteptare.

Testul trebuie să calculeze independent ce ar trebui să iasă:

JavaScript
const j = pm.response.json();
const subtotal = j.items.reduce((s, it) => s + it.price * it.quantity, 0);
const reducere = subtotal >= 100 ? Math.round(subtotal * 0.10 * 100) / 100 : 0;
const asteptat = Math.round((subtotal - reducere) * 100) / 100;

pm.test("Totalul aplică REDUCERE10 corect", function () {
    pm.expect(j.subtotal).to.equal(subtotal);
    pm.expect(j.discount).to.equal(reducere);
    pm.expect(j.total).to.equal(asteptat);
});

Principii:

  • regula vine din cerințe, nu din cod sau din răspuns; dacă API-ul calculează greșit, testul trebuie să pice;
  • rotunjirea e specificată (la bani, la fiecare linie sau la total); diferențe de 0,01 sunt bug-uri reale în facturare;
  • zecimalele în JavaScript (0.1 + 0.2) cer rotunjire sau closeTo(asteptat, 0.001);
  • valorile limită: subtotal exact 100, sub 100, cupon expirat, cantitate maximă.

Pentru multe combinații, cazurile intră într-un CSV cu valorile așteptate calculate de mână, rulat data-driven.

Ce urmărește intervievatorul: Testează gândirea de tester, nu doar sintaxa: oracolul independent și rotunjirile. Răspunsul slab compară totalul cu el însuși.

70 Senior

Cum decizi ce merită verificat în testele Postman ale unui endpoint și ce e prea mult?

Răspuns scurt: Verifici contractul (status, schemă, antete), regulile de business și efectele secundare importante. Eviți aserțiunile pe date volatile, pe ordinea neprecizată și duplicarea aceleiași verificări peste tot. Fiecare aserțiune trebuie să prindă un bug realist.

Prea puține aserțiuni lasă bug-uri să treacă; prea multe fac suita fragilă și nimeni nu mai crede în ea când pică.

Ce merită:

  • contractul: status exact, Content-Type, schema body-ului, antetele cu rol (Location, paginare);
  • regulile de business: calcule, filtre, drepturi, tranziții de stare (o comandă livrată nu se poate anula);
  • efectele: după POST, resursa există; după DELETE, nu mai există; stocul a scăzut;
  • erorile: structura și mesajele pentru cazurile documentate.

Ce e prea mult sau fragil:

  • valori care se schimbă legitim (timestampuri, ID-uri generate, numărul total de produse);
  • ordinea elementelor când API-ul nu o garantează;
  • textul exact al mesajelor de eroare, dacă nu e parte din contract;
  • aceeași verificare pe fiecare cerere, în loc de o singură dată în scriptul colecției;
  • praguri de timp strânse.

Criteriul practic: pentru fiecare aserțiune te întrebi ce bug realist prinde. Dacă răspunsul e „niciunul” sau „pică și când totul e bine”, o scoți. Un indicator bun e rata de eșecuri false din CI: dacă e mare, suita verifică lucruri greșite.

Ce urmărește intervievatorul: Întrebare senior despre designul aserțiunilor. Se urmărește criteriul „ce bug prinde”, nu o listă memorată.

71 Senior

Cum folosești Postman pentru teste de regresie pe un API care primește o versiune nouă (v1 → v2)?

Răspuns scurt: Rulezi aceeași colecție pe v1 și v2 și compari rezultatele, verifici că v1 rămâne neschimbată pentru clienții vechi, adaugi teste pentru schimbările documentate în v2 și urmărești câmpurile depreciate și antetele de deprecare.

O versiune nouă de API are două riscuri: v2 nu face ce trebuie și, mai grav, v1 se strică pentru clienții existenți.

1. Versiunea ca variabilă. Cererile folosesc {{baseUrl}}/{{versiune}}/products, sau antetul de versiune, ca aceeași colecție să ruleze pe ambele.

2. v1 neatinsă. Colecția v1 rulează în CI neschimbată. Orice eșec după lansarea v2 e o problemă de compatibilitate, chiar dacă v2 e corectă.

3. Diferențele documentate. Pentru v2, un folder cu testele schimbărilor din changelog: câmpuri redenumite, tipuri schimbate, paginare nouă. Schema v2 separată de schema v1.

4. Comparație automată. Pe endpointurile care ar trebui să întoarcă aceleași date, un script compară răspunsurile v1 și v2 (prin pm.sendRequest) pe câmpurile comune.

5. Deprecare. v1 trimite antete ca Deprecation și Sunset, iar documentația anunță data. Le verifici în teste.

6. Clienți reali. Ce versiune folosesc aplicația mobilă și integrările partenerilor? Testele pe v1 trebuie să acopere fluxurile lor, nu doar endpointurile ușor de testat.

Ce urmărește intervievatorul: Întrebare senior despre compatibilitate. Se apreciază accentul pe protejarea clienților existenți.

Collection Runner și testare data-driven

72 Junior

Ce este Collection Runner și ce opțiuni configurezi înainte de o rulare?

Răspuns scurt: Unealta care rulează toate cererile unei colecții sau ale unui folder, în ordine, cu testele lor. Configurezi environment-ul, numărul de iterații, întârzierea dintre cereri, fișierul de date și dacă păstrezi răspunsurile și variabilele.

Collection Runner transformă colecția într-o suită de teste rulată dintr-o singură apăsare. Îl deschizi din meniul colecției sau al folderului cu Run.

Opțiuni importante:

  • ordinea și selecția cererilor: poți debifa cereri sau le poți rearanja pentru o rulare;
  • Environment: mediul folosit;
  • Iterations: de câte ori rulează tot setul;
  • Delay: pauza în milisecunde între cereri, utilă la API-uri cu limită de rată;
  • Data file: un CSV sau JSON, câte un rând pe iterație;
  • Persist responses for a session și păstrarea valorilor variabilelor după rulare;
  • Keep variable values: dacă variabilele setate în rulare rămân după ea.

Rezultatul arată, pentru fiecare cerere și iterație, statusul, timpul și testele trecute sau picate, cu filtre pe eșecuri. Rezultatele se pot exporta.

Diferențe față de trimiterea manuală: pm.execution.setNextRequest funcționează doar aici și în Newman, iar variabilele de date (pm.iterationData) există doar când e încărcat un fișier.

Ce urmărește intervievatorul: Verifică familiaritatea cu rularea în bloc. Mențiunea despre setNextRequest și variabilele de date arată înțelegere.

Eroarea, în practică:401 în Runner, deși merge la Send

73 Junior

Cum faci testare data-driven în Postman cu un fișier CSV?

Răspuns scurt: Scrii cererea cu variabile ({{email}}, {{parola}}, {{statusAsteptat}}), pregătești un CSV cu antetul pe primul rând și câte un caz pe rând, îl încarci în Runner, iar testul compară rezultatul cu valoarea din pm.iterationData.

Data-driven înseamnă: aceeași cerere, multe seturi de date, fiecare cu rezultatul așteptat.

Fișierul login.csv:

email,parola,statusAsteptat
ana@magazin.test,Parola123!,200
ana@magazin.test,gresita,401
,Parola123!,422
nimeni@magazin.test,Parola123!,401

Cererea POST {{baseUrl}}/auth/login cu body:

JSON
{ "email": "{{email}}", "password": "{{parola}}" }

Testul:

JavaScript
const asteptat = Number(pm.iterationData.get("statusAsteptat"));
pm.test("Login " + pm.iterationData.get("email") + " → " + asteptat, function () {
    pm.response.to.have.status(asteptat);
});

În Runner alegi fișierul la Data, iar numărul de iterații se ia din numărul de rânduri. Câteva detalii: valorile din CSV sunt text, deci convertești cu Number; numele testului include datele, ca în raport să vezi ce caz a picat; previzualizarea fișierului din Runner te ajută să vezi dacă separatorul și ghilimelele au fost înțelese corect.

Ce urmărește intervievatorul: Întrebare practică de bază. Se urmărește includerea rezultatului așteptat în date și numele de test care identifică rândul.

Eroarea, în practică:{{email}} trimis literal (variabilă de date)Coloana din CSV are alt nume decât variabila

74 Junior

CSV sau JSON ca fișier de date în Postman: când îl alegi pe fiecare?

Răspuns scurt: CSV e simplu și ușor de editat în Excel, bun pentru valori plate. JSON (un array de obiecte) permite valori structurate: liste, obiecte imbricate, numere și boolean cu tipul lor, null.

CSV:

  • ușor de scris și de citit de oricine, inclusiv de analiști, în Excel sau Google Sheets;
  • potrivit pentru valori simple: emailuri, coduri, statusuri;
  • toate valorile sunt text, iar o celulă goală devine șir gol;
  • capcane: virgulele din valori cer ghilimele, salvarea din Excel poate adăuga BOM sau separatorul ;, iar diacriticele cer UTF-8.

JSON (obligatoriu un array de obiecte, nu un obiect):

JSON
[
  { "caz": "coș cu două produse", "items": [{"productId": 7, "quantity": 2}], "total": 178 },
  { "caz": "cantitate zero", "items": [{"productId": 7, "quantity": 0}], "status": 422 }
]
  • păstrează tipurile (număr, boolean, null);
  • permite structuri (liste de produse în coș), pe care în CSV ar trebui să le codezi ca text;
  • poate avea câmpuri diferite pe cazuri.

În body, o valoare structurată din JSON se pune cu JSON.stringify(pm.iterationData.get("items")) într-o variabilă locală. Regula practică: CSV pentru tabele simple, JSON imediat ce ai nevoie de o listă sau de tipuri.

Ce urmărește intervievatorul: Testează cunoașterea compromisurilor. Detaliul că JSON trebuie să fie array e o greșeală frecventă.

Eroarea, în practică:Fișierul JSON de date nu e o listă

75 Junior

Cum includ în fișierul de date atât cazuri pozitive, cât și negative, fără cereri separate?

Răspuns scurt: Adaugi coloane cu rezultatul așteptat (status, cod de eroare, câmp de verificat) și un nume de caz. Testul citește așteptările din rând și aplică verificările potrivite: pentru succes verifică datele, pentru eroare verifică structura erorii.

Cheia e ca fișierul să conțină și așteptarea, nu doar datele de intrare:

caz,productId,quantity,status,eroare
adăugare normală,7,2,201,
cantitate zero,7,0,422,validation_error
cantitate peste limită,7,11,422,validation_error
produs inexistent,999,1,404,not_found
stoc insuficient,12,5,409,out_of_stock

Testul se adaptează după rând:

JavaScript
const d = pm.iterationData;
const status = Number(d.get("status"));
pm.test(d.get("caz") + " → " + status, function () {
    pm.response.to.have.status(status);
    if (status >= 400) {
        pm.expect(pm.response.json().error).to.equal(d.get("eroare"));
    } else {
        pm.expect(pm.response.json().quantity).to.equal(Number(d.get("quantity")));
    }
});

Avantaje: adaugi un caz nou scriind un rând, iar fișierul devine o documentație a regulilor. Limită: dacă verificările pentru cazuri diferă mult, testul se umple de if-uri și devine greu de citit; atunci separi pozitivele de negative în două cereri cu fișiere diferite.

Ce urmărește intervievatorul: Verifică proiectarea datelor de test. Se apreciază coloana de nume de caz și recunoașterea limitei.

Eroarea, în practică:Variabilă rămasă din iterația anterioară

76 Mid

Cum folosești setNextRequest ca să construiești un flux condiționat în Collection Runner?

Răspuns scurt: În Post-response alegi următoarea cerere după rezultat: pm.execution.setNextRequest("Nume cerere") sare la ea, null oprește rularea. Așa faci ramificări (stoc → comandă, altfel oprire) sau bucle (paginare, polling).

Implicit, Runner execută cererile în ordinea din colecție. pm.execution.setNextRequest schimbă ordinea:

JavaScript
// după GET /products/12
const stoc = pm.response.json().stock;
if (stoc > 0) {
    pm.execution.setNextRequest("Adaugă în coș");
} else {
    console.warn("Produs fără stoc, oprim fluxul");
    pm.execution.setNextRequest(null);
}

Folosiri tipice:

  • ramificare: dacă login-ul eșuează, nu mai rulezi restul fluxului (evitând zeci de eșecuri în cascadă);
  • buclă: paginare sau așteptarea unui job (status încă processing → aceeași cerere din nou);
  • sărirea unor pași pe un anumit mediu.

Reguli importante:

  • numele trebuie să fie exact numele cererii (sau ID-ul ei); unul greșit oprește rularea;
  • funcționează doar în Runner și Newman, nu la Send manual;
  • se aplică după terminarea cererii curente, nu imediat;
  • orice buclă are nevoie de o limită (un contor în variabilă), altfel un bug al API-ului îți blochează rularea.

Fluxurile foarte ramificate devin greu de urmărit; dacă ai multe, e semn că logica ar sta mai bine într-un test în cod.

Ce urmărește intervievatorul: Testează controlul fluxului în Runner. Limita pentru bucle e un detaliu de experiență.

Eroarea, în practică:setNextRequest nu are efect la SendsetNextRequest cu nume greșit oprește rularea

77 Mid

Cum testezi în Postman un endpoint care pornește un job asincron (202) și trebuie verificat când se termină?

Răspuns scurt: Prima cerere primește 202 și un id de job; o a doua cerere interoghează starea și, cât timp e „processing”, se re-execută cu setNextRequest și o pauză, până la „done” sau la un număr maxim de încercări. Apoi verifici rezultatul.

Endpointurile asincrone (exporturi, importuri, rapoarte) nu se pot verifica într-o singură cerere.

1. Pornirea. POST /reports → 202 Accepted, cu jobId și eventual antetul Location spre starea jobului. Salvezi ID-ul și resetezi contorul de încercări.

2. Polling. GET /reports/{{jobId}}:

JavaScript
const j = pm.response.json();
const incercari = Number(pm.collectionVariables.get("incercari") || 0) + 1;
pm.collectionVariables.set("incercari", incercari);

if (j.status === "processing" && incercari < 10) {
    setTimeout(function () {}, 2000);           // pauză înainte de cererea următoare
    pm.execution.setNextRequest(pm.info.requestName);
} else {
    pm.test("Jobul s-a terminat cu succes", function () {
        pm.expect(j.status).to.equal("done");
        pm.expect(j.url).to.be.a("string");
    });
}

3. Rezultatul. Descarci fișierul și verifici conținutul.

Ce mai testezi: un job inexistent dă 404, jobul altui utilizator dă 403 sau 404, un job eșuat întoarce status: "failed" cu motiv. Pauza poate fi pusă și din opțiunea Delay a Runner-ului; limita de încercări face ca un job blocat să producă un test roșu, nu o rulare infinită.

Ce urmărește intervievatorul: Întrebare practică de nivel mediu. Se urmărește polling-ul cu limită și verificarea rezultatului final.

78 Mid

Rularea data-driven trece la primele iterații, apoi pică la toate cele de după un anumit rând. Ce cauze cauți?

Răspuns scurt: Stare rămasă de la iterațiile anterioare (stoc consumat, email deja înregistrat, cont blocat după încercări greșite), limită de rată, token expirat pe parcurs sau un rând de date malformat care strică variabilele pentru restul rulării.

Eșecurile „de la rândul N încolo” au aproape mereu o cauză de stare, nu de date.

Ce verifici:

  • efecte acumulate: fiecare iterație adaugă în coș, deci la iterația 6 depășești stocul; fiecare înregistrare folosește același email, iar de la a doua primești 409;
  • blocare de securitate: rândurile cu parolă greșită blochează contul după 5 încercări, iar login-urile corecte de după primesc 429 sau 423;
  • limită de rată: 100 de cereri pe minut; fără Delay, la un moment dat începe 429;
  • token expirat în timpul unei rulări lungi;
  • variabile suprascrise: un rând fără valoare pentru o coloană lasă variabila goală, iar un script salvează undefined folosit apoi de toate iterațiile;
  • un rând malformat în CSV (o virgulă în plus) care decalează coloanele.

Diagnostic: te uiți în Runner la prima iterație care pică, compari cererea ei cu una reușită în Console și rulezi acel rând izolat. Remedii: date unice per iterație ({{$randomEmail}}), curățenie între iterații, Delay, refresh automat de token, rânduri negative grupate la final sau separate.

Ce urmărește intervievatorul: Testează diagnosticul sistematic. Exemplul cu blocarea contului din rândurile negative e foarte realist.

79 Senior

Când nu mai e Postman unealta potrivită pentru testarea data-driven și ce ai alege în schimb?

Răspuns scurt: Când ai mii de combinații generate, logică complexă de pregătire a datelor, nevoie de acces direct la baza de date sau verificări încrucișate cu alte sisteme. Atunci treci la un framework de cod (Playwright, RestAssured, pytest) cu date generate programatic.

Postman e excelent pentru zeci sau câteva sute de cazuri descrise într-un fișier. Semnele că ai depășit zona lui:

  • combinații generate: vrei toate combinațiile a 5 parametri cu câte 6 valori; un CSV de 7.776 de rânduri nu mai e întreținut de oameni;
  • pregătire complexă: fiecare caz cere crearea unor date în mai multe servicii, cu dependențe;
  • verificare în alte surse: trebuie să citești din baza de date sau dintr-o coadă de mesaje că efectul s-a produs;
  • scripturi mari: testul are 200 de linii cu if-uri după coloanele din fișier;
  • lucru în echipă pe cod: review pe un JSON de colecție de 10.000 de linii e greu, iar refactorizarea lipsește;
  • rulare paralelă și raportare avansată.

Alternative: un framework de teste în codul proiectului, cu teste parametrizate (pytest parametrize, JUnit @ParameterizedTest, Playwright cu bucle pe date), generatori de date și acces la DB.

Nu e o alegere „sau-sau”: Postman rămâne pentru explorare, documentație și smoke teste rapide, iar cazurile combinatorii și complexe se mută în cod.

Ce urmărește intervievatorul: Întrebare senior de judecată. Se urmărește că știi limitele uneltei și argumentezi trecerea.

80 Senior

Cum ai proiecta datele de test pentru o suită Postman care rulează zilnic pe un mediu partajat cu alte echipe?

Răspuns scurt: Date izolate și identificabile (prefix, utilizatori dedicați), create de suită la început și șterse la final, fără dependență de date create manual. Valorile unice se generează, iar verificările nu presupun că suita e singura care modifică mediul.

Pe un mediu partajat, alte echipe modifică date în paralel, deci suita trebuie să fie autonomă și tolerantă.

Izolare:

  • utilizatori de test dedicați suitei (qa-postman-1@...), pe care nimeni altcineva nu îi folosește;
  • date create de suită cu un prefix ([AUTO] Mouse test 20261104), ușor de găsit și de curățat;
  • nu modifici date comune (produsul 7 folosit de toată lumea) dacă nu ai creat tu copia.

Ciclu de viață:

  • folderul 00 Setup creează ce trebuie (produs, cupon, utilizator) și salvează ID-urile;
  • folderul 99 Cleanup șterge tot, inclusiv la rulări eșuate (Newman continuă implicit după testele picate);
  • un job separat curăță periodic datele cu prefix rămase.

Toleranță:

  • nu verifici totaluri globale (numărul de produse), doar ce ai creat;
  • valorile unice se generează ({{$guid}}, timestamp), ca rulări paralele să nu se ciocnească;
  • când o verificare depinde de date externe, o legi de date create de tine.

Documentezi ce creează suita, ca celelalte echipe să știe ce înseamnă datele [AUTO] din mediu.

Ce urmărește intervievatorul: Întrebare senior despre medii realiste. Se apreciază setup/cleanup explicit și toleranța la alte echipe.

Newman, CI și raportare

81 Junior

Ce este Newman și cum rulezi o colecție din linia de comandă?

Răspuns scurt: Newman e rulatorul de colecții Postman pentru linia de comandă, instalat din npm. Exporți colecția și environment-ul ca JSON și rulezi newman run colectie.json -e mediu.json.

Newman execută o colecție Postman fără interfață grafică, exact ca Collection Runner: aceleași cereri, scripturi și teste. E baza rulării în CI.

Instalare (cere Node.js):

BASH
npm install -g newman

Rulare:

BASH
newman run Magazin.postman_collection.json -e Staging.postman_environment.json

Opțiuni folosite des:

  • -e / --environment: fișierul de environment;
  • -g / --globals: variabilele globale;
  • -d / --iteration-data: fișier CSV sau JSON pentru data-driven;
  • -n / --iteration-count: numărul de iterații;
  • --folder "Produse": doar un folder;
  • --delay-request 200: pauză între cereri;
  • --timeout-request 5000: timeout pe cerere;
  • --env-var "token=abc": suprascrie o variabilă din linia de comandă;
  • -r cli,junit: reporterii.

Colecția poate fi și o adresă URL (exportul din API-ul Postman, cu cheie API), dar cel mai sigur pentru reproducere e fișierul din repository. La final, Newman afișează un tabel cu cererile, testele și eșecurile.

Ce urmărește intervievatorul: Verifică dacă știi să scoți testele din interfață. Lista de opțiuni arată folosire reală.

Eroarea, în practică:command not found: newmancollection could not be loaded

82 Junior

Ce înseamnă exit code-ul lui Newman și de ce e important în CI?

Răspuns scurt: Newman se termină cu 0 dacă toate testele au trecut și cu 1 dacă a picat vreun test sau a apărut o eroare. Pipeline-ul folosește codul ca să marcheze pasul roșu și să oprească livrarea.

Sistemele de CI nu citesc rapoartele; decid după exit code-ul comenzii:

  • 0: toate testele au trecut și nu au fost erori;
  • 1: cel puțin un test a picat, o cerere a dat eroare de rețea sau un script a aruncat excepție;
  • alte coduri: probleme ale comenzii însăși (de exemplu 127 când shell-ul nu găsește newman).

De ce contează:

  • un pas cu exit code nenul oprește pipeline-ul, deci un API stricat nu ajunge mai departe;
  • dacă scrii comanda newman run ... || true sau continue-on-error, ascunzi toate eșecurile; pipeline-ul e verde mereu și testele nu mai protejează nimic;
  • opțiunea --bail oprește rularea la primul eșec (feedback mai rapid, dar raport incomplet);
  • --suppress-exit-code există pentru situații speciale (de exemplu un raport informativ), nu pentru a „repara” un pipeline roșu.

Când pipeline-ul pică, citești în log tabelul de final și secțiunea de eșecuri: Newman spune cererea, testul și mesajul aserțiunii, de exemplu „expected response to have status code 200 but got 500”.

Ce urmărește intervievatorul: Întrebare de bază pentru CI. Se urmărește că știi pericolul ascunderii codului de ieșire.

Eroarea, în practică:Newman: exit code 1Process completed with exit code 1 (CI)

83 Junior

Ce reporteri are Newman și cum obții un raport JUnit sau HTML?

Răspuns scurt: Implicit cli; incluși mai sunt json, junit și progress, iar htmlextra se instalează separat. Îi alegi cu -r și setezi fișierul cu --reporter-<nume>-export.

Reporterii decid ce produce rularea:

  • cli: tabelul din terminal, implicit;
  • json: tot rezultatul, detaliat, pentru prelucrări proprii;
  • junit: XML în format JUnit, citit de Jenkins, GitLab, Azure DevOps și GitHub Actions (cu o acțiune de raportare);
  • progress, emojitrain: variante de afișare în terminal;
  • htmlextra (pachet separat, newman-reporter-htmlextra): un raport HTML detaliat, cu cereri, răspunsuri și teste, bun de arhivat ca artefact.

Exemplu:

BASH
npm install -g newman newman-reporter-htmlextra
newman run colectie.json -e staging.json \
  -r cli,junit,htmlextra \
  --reporter-junit-export rezultate/junit.xml \
  --reporter-htmlextra-export rezultate/raport.html

Fără --reporter-...-export, fișierul ajunge într-un folder newman/ cu nume generat, iar CI-ul nu-l găsește la calea așteptată. Atenție la ce intră în rapoartele HTML: pot conține tokenuri și date personale din cereri; htmlextra are opțiuni pentru a ascunde antete sensibile.

Ce urmărește intervievatorul: Verifică dacă știi să integrezi rezultatele în CI. Detaliul cu calea explicită de export rezolvă o problemă frecventă.

Eroarea, în practică:could not find "htmlextra" reporter

84 Junior

Testele trec în Postman, dar pică în Newman. Care sunt cauzele cele mai probabile?

Răspuns scurt: Environment-ul exportat nu are Current value (tokenuri, URL-uri locale), variabile globale lipsă, fișiere referite cu cale locală, versiune veche de colecție, cookie-uri sau setări din aplicație care nu există în Newman, rețea diferită în CI.

Diferențele vin aproape mereu din ce are aplicația Postman și nu ajunge în fișiere:

  • Current value: exportul environment-ului conține doar Initial value; tokenul sau parola din Current value lipsesc, deci primești 401 sau {{token}} nerezolvat;
  • globale: le-ai folosit în Postman, dar n-ai trimis -g globals.json;
  • versiunea colecției: rulezi un export vechi din repository;
  • cookie-uri: în aplicație ai un cookie de sesiune din cereri anterioare, în Newman pornești curat;
  • setări: certificate client, proxy sau „SSL verification off” configurate în aplicație; în Newman cer opțiuni explicite (--insecure, --ssl-client-cert);
  • fișiere: form-data cu un fișier de pe laptopul tău (/Users/ana/poza.png), inexistent în CI;
  • rețea: localhost sau un server intern accesibil de pe laptop, dar nu din runner-ul CI;
  • ordinea: în aplicație ai trimis cererile manual în altă ordine.

Diagnostic: rulezi Newman local cu exact aceleași fișiere ca CI-ul și opțiunea --verbose, care arată cererile și răspunsurile. Dacă pică și local, problema e în fișiere; dacă trece local și pică în CI, e mediul.

Ce urmărește intervievatorul: Întrebare foarte practică. Răspunsul bun începe cu Current value, cauza numărul unu.

Eroarea, în practică:could not load environmentNewman: ENOTFOUND {{baseurl}} fără -e

85 Mid

Cum integrezi rularea Newman într-un pipeline (de exemplu GitHub Actions) cu secretele în siguranță?

Răspuns scurt: Un job care instalează Newman, rulează colecția din repository cu environment-ul fără secrete și primește secretele din secretele pipeline-ului prin --env-var, publică raportul JUnit și pică dacă pică testele.

Un exemplu complet în GitHub Actions:

YAML
jobs:
  teste-api:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20 }
      - run: npm install -g newman
      - run: >
          newman run postman/magazin.postman_collection.json
          -e postman/staging.postman_environment.json
          --env-var "parola=${{ secrets.QA_PAROLA }}"
          --env-var "apiKey=${{ secrets.QA_API_KEY }}"
          -r cli,junit --reporter-junit-export rezultate/junit.xml
      - uses: actions/upload-artifact@v4
        if: always()
        with: { name: rezultate-api, path: rezultate/ }

Principii:

  • colecția și environment-ul vin din repository, deci rulezi exact versiunea codului;
  • secretele nu stau în fișiere, ci în secretele pipeline-ului, injectate cu --env-var; CI-ul le maschează în log;
  • if: always() păstrează raportul și când testele pică, exact când ai nevoie de el;
  • versiunea Newman e fixată (newman@6.x) ca o actualizare să nu schimbe comportamentul peste noapte;
  • jobul rulează după deploy-ul pe mediul de test, nu înainte.

Ce urmărește intervievatorul: Verifică experiența practică de CI. Detaliile if: always() și versiunea fixată arată că ai întreținut un pipeline real.

Eroarea, în practică:Process completed with exit code 1 (CI)

86 Mid

Cum rulezi Newman programatic din Node.js și când e util?

Răspuns scurt: Cu require('newman').run({collection, environment, reporters}, callback) sau ascultând evenimentele (request, assertion, done). Util când vrei logică în jurul rulării: mai multe colecții, notificări, rapoarte proprii, decizii după rezultate.

Newman e și o bibliotecă Node.js:

JavaScript
const newman = require("newman");

newman.run({
    collection: require("./magazin.postman_collection.json"),
    environment: "./staging.postman_environment.json",
    envVar: [{ key: "parola", value: process.env.QA_PAROLA }],
    reporters: ["cli", "junit"],
    reporter: { junit: { export: "./rezultate/junit.xml" } }
})
.on("assertion", function (err, a) {
    if (err) console.log("PICAT:", a.item.name, "-", a.assertion);
})
.on("done", function (err, summary) {
    const picate = summary.run.failures.length;
    process.exit(err || picate ? 1 : 0);
});

Când merită:

  • rulezi mai multe colecții sau medii în paralel și combini rezultatele;
  • trimiți un mesaj în Slack sau Teams doar cu eșecurile;
  • construiești un raport propriu (de exemplu timpi pe endpoint în timp);
  • decizi pași următori după rezultat (rerulare a unui folder, oprire).

Atenție să păstrezi exit code-ul corect, cum face process.exit din exemplu; altfel scriptul tău ascunde eșecurile de CI.

Ce urmărește intervievatorul: Întrebare de nivel mediu care separă utilizatorii de linie de comandă de cei care au automatizat în jurul Newman.

87 Mid

Ce diferențe sunt între Newman și Postman CLI și pe care l-ai alege?

Răspuns scurt: Newman e open-source, rulează fișiere exportate și are mulți reporteri din comunitate. Postman CLI e unealta oficială nouă, rulează colecții direct din cloud după ID, trimite rezultatele înapoi în Postman și suportă reguli de guvernanță; cere cheie API.

Ambele rulează colecții din linia de comandă, dar pornesc din filozofii diferite.

Newman:

  • open-source, instalat din npm;
  • rulează fișiere JSON exportate, deci funcționează fără cont și fără internet spre Postman;
  • ecosistem mare de reporteri (htmlextra, allure);
  • folosibil ca bibliotecă Node.js.

Postman CLI:

  • unealta oficială, întreținută de Postman, binar separat;
  • rulează colecții și environment-uri după ID, direct din workspace, cu postman login și o cheie API;
  • trimite rezultatele în Postman, unde echipa vede istoricul rulărilor;
  • poate verifica reguli de guvernanță și securitate pe definițiile API;
  • suportă și fișiere locale.

Alegerea:

  • dacă colecțiile sunt versionate în git lângă cod și vrei independență de cloud → Newman;
  • dacă echipa lucrează în workspace-uri Postman și vrea rezultatele centralizate acolo → Postman CLI;
  • dacă există restricții de securitate care interzic trimiterea datelor spre un serviciu extern → Newman.

La interviu contează argumentul, nu alegerea în sine.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu ecosistemul și dacă alegi uneltele cu argumente.

88 Senior

Cum organizezi rularea testelor Postman în CI pe mai multe niveluri: la fiecare commit, după deploy și programat?

Răspuns scurt: La pull request: un smoke rapid pe mediul efemer sau de dev. După deploy pe staging: colecția completă, inclusiv negativele. Programat (noaptea): fluxuri lungi, date mari, verificări de securitate. În producție: doar smoke nedistructiv, cu monitorizare.

O singură rulare „a tot” e fie prea lentă pentru fiecare commit, fie prea superficială pentru încredere. O structură pe niveluri:

1. Pull request (minute): folderele de smoke (endpointuri principale, login, un flux de cumpărare), rulate pe un mediu efemer sau pe dev. Pică → nu se face merge.

2. După deploy pe staging (zeci de minute): toată colecția, cu teste negative, autorizare și validare de schemă. Pică → nu se promovează build-ul.

3. Programat, noaptea: data-driven mare, fluxuri lungi, paginare completă, verificări de securitate de bază, teste de compatibilitate v1/v2. Rezultatele merg într-un canal și creează tichete.

4. Producție: doar GET-uri și fluxuri care nu modifică date reale, eventual ca Monitor Postman la fiecare câteva minute, cu alertă.

Practic, nivelurile se fac cu --folder sau cu colecții separate, toate din același repository. Mai contează: rezultatele JUnit publicate în CI pentru istoric, timpul fiecărui nivel urmărit (un smoke care ajunge la 15 minute nu mai e smoke) și o regulă clară pentru testele instabile: se repară sau se scot, nu se ignoră.

Ce urmărește intervievatorul: Întrebare senior de strategie. Se urmărește potrivirea fiecărui nivel cu un risc și un timp de feedback.

89 Senior

Suita Newman din CI pică intermitent, cam o dată din cinci rulări, fără schimbări de cod. Cum abordezi problema?

Răspuns scurt: Strângi date: care teste pică, la ce oră, cu ce mesaj. Cauzele tipice sunt dependențe de date partajate, ordinea și starea, limite de rată, timeouturi, praguri de timp strânse, tokenuri expirate. Repari cauza, nu adaugi retry orb.

Testele intermitente distrug încrederea în pipeline: după câteva alarme false, echipa începe să ignore roșul.

1. Date, nu impresii. Din rapoartele JUnit ale ultimelor rulări extragi testele care pică, mesajele și momentele. De obicei sunt 2–3 teste responsabile de majoritatea eșecurilor.

2. Cauze tipice și ce cauți:

  • prag de timp („expected 1250 to be below 1000”) → prag nerealist pentru mediul CI;
  • date partajate (alt job sau altă echipă modifică produsul folosit) → date proprii, create la setup;
  • 429 sau ECONNRESET la rafale → --delay-request, respectarea Retry-After;
  • ESOCKETTIMEDOUT → --timeout-request adecvat sau o problemă reală de performanță de raportat;
  • ordine și stare (variabile rămase, joburi asincrone neterminate) → polling cu limită, curățenie;
  • token expirat în rulări lungi → refresh automat;
  • mediu instabil (deploy în timpul rulării) → sincronizarea pipeline-urilor.

3. Remediere și prevenție. Repari cauza; retry-ul automat ascunde bug-uri reale de concurență. Până la reparare, testul poate fi mutat într-un folder „în carantină”, rulat separat, cu tichet și termen. Și urmărești rata de eșecuri false ca indicator.

Ce urmărește intervievatorul: Întrebare senior despre stabilitate. Se apreciază analiza bazată pe date și refuzul retry-ului ca soluție universală.

Mock servers, contracte și monitorizare

Exersează capitolul cu exerciții reale: Curs Postman →
90 Junior

Ce e un mock server în Postman și când îl folosești?

Răspuns scurt: Un server simulat, creat din colecție, care răspunde cu exemplele salvate. Îl folosești când API-ul real nu e gata, ca frontend-ul sau testele să poată lucra în paralel, ori când vrei răspunsuri controlate (erori, cazuri rare).

Un mock server Postman primește o adresă proprie (https://<id>.mock.pstmn.io) și răspunde la cereri folosind exemplele salvate în colecție. Nu are logică: caută exemplul potrivit cu metoda și calea și îl întoarce.

Când e util:

  • dezvoltare în paralel: echipa de frontend sau de mobil lucrează pe contract înainte ca backend-ul să existe;
  • cazuri greu de reprodus: o eroare 503, un timeout, o listă goală, un câmp null;
  • dependențe externe: un serviciu de plăți sau de curierat pe care nu-l poți apela în teste;
  • demo-uri și documentație interactivă.

Cum îl creezi: salvezi exemple pe cereri (de exemplu GET /products/7 cu 200 și GET /products/999 cu 404), apoi din meniul colecției alegi Mock collection. Setezi baseUrl într-un environment „Mock” spre adresa mock-ului și rulezi aceleași cereri.

Limită esențială: mock-ul nu are stare și nu validează nimic. Un POST „reușit” nu creează nimic, iar un body greșit primește tot răspunsul salvat. Testele pe mock verifică clientul, nu API-ul.

Ce urmărește intervievatorul: Verifică înțelegerea rolului mock-urilor și a limitelor lor. Răspunsul slab crede că mock-ul „testează API-ul”.

Eroarea, în practică:Cloud Agent: Can't send requests to localhostmockRequestNotFoundError

91 Junior

Cum alege mock server-ul Postman ce exemplu întoarce și cum forțezi un anumit răspuns, de exemplu 404?

Răspuns scurt: Potrivește metoda și calea (inclusiv parametrii) cu exemplele salvate și alege cel mai apropiat. Pentru un exemplu anume trimiți antetul x-mock-response-code: 404 sau x-mock-response-name cu numele exemplului.

Algoritmul de potrivire ține cont, în ordine aproximativă, de:

  • metoda HTTP (un exemplu de GET nu răspunde la POST);
  • calea exactă sau cea mai apropiată;
  • parametrii de query, antetele și body-ul, dacă activezi potrivirea pe ele;
  • dacă rămân mai multe exemple, preferința pentru un răspuns 2xx.

Când nimic nu se potrivește, mock-ul răspunde cu 404 și eroarea mockRequestNotFoundError („Double check your method and the request path and try again”). Cauze tipice: altă metodă, o bară în plus la final, calea scrisă diferit față de exemplu.

Ca să alegi explicit răspunsul, trimiți antete speciale:

x-mock-response-code: 404
x-mock-response-name: Produs inexistent

Așa testezi cum se comportă clientul la erori fără să schimbi URL-ul. Mai există x-mock-match-request-body: true pentru potrivirea după body. Pentru fiecare endpoint important merită salvate exemple pentru succes, eroare de validare, lipsă de drepturi și eroare de server, cu nume clare.

Ce urmărește intervievatorul: Întrebare practică despre mock-uri. Antetul x-mock-response-code e detaliul pe care îl caută intervievatorul.

Eroarea, în practică:mockRequestNotFoundError

92 Junior

Ce sunt Monitors în Postman și cum le folosești pentru un API în producție?

Răspuns scurt: Rulări programate ale unei colecții din cloud-ul Postman (de exemplu la fiecare 5 minute), cu alerte prin email sau integrări când pică testele. În producție le folosești pentru verificări nedistructive: disponibilitate, timp, conținut de bază.

Un Monitor rulează o colecție (sau un folder) periodic, de pe serverele Postman, din regiunile alese. Rezultatele (teste trecute, timpi) se păstrează în istoric, iar la eșec primești notificare prin email, Slack sau alte integrări.

Ce monitorizezi în producție:

  • endpointul de sănătate (/health) și câteva GET-uri esențiale (catalog, căutare);
  • statusul, timpul de răspuns și câteva câmpuri cheie;
  • un login cu un cont tehnic dedicat;
  • certificatul și redirecționarea HTTP → HTTPS.

Ce nu faci: cereri care creează comenzi, plăți sau date reale; teste care depind de date volatile; cereri prea dese, care încarcă inutil serverul sau consumă limita de rată.

Detalii practice: environment dedicat monitorului, cu cont fără drepturi de scriere; secretele în Current value nu ajung în cloud, deci pentru monitor ai nevoie de variabile setate explicit în configurarea lui; un singur eșec izolat poate fi rețeaua, deci alerta e mai utilă la eșecuri repetate. Monitoarele nu înlocuiesc o soluție completă de observabilitate, dar prind repede o problemă din perspectiva clientului.

Ce urmărește intervievatorul: Verifică dacă știi de monitorizarea sintetică și limitele ei. Se apreciază regula „nedistructiv în producție”.

93 Mid

Cum folosești o specificație OpenAPI pentru a verifica dacă API-ul real respectă contractul, folosind Postman?

Răspuns scurt: Imporți specificația și generezi colecția, apoi în teste validezi răspunsurile contra schemelor din specificație (copiate sau încărcate), verifici codurile documentate pentru fiecare operație și raportezi diferențele.

Specificația OpenAPI e contractul. Postman ajută să verifici că implementarea îl respectă.

1. Colecție din specificație. Imporți openapi.yaml; Postman creează câte o cerere pe operație. Dacă folosești secțiunea APIs, colecția rămâne legată de definiție și primești avertismente când diferă.

2. Scheme în teste. Schemele din components/schemas le pui în variabile de colecție (un script le poate încărca dintr-un URL cu pm.sendRequest), apoi:

JavaScript
const schema = JSON.parse(pm.collectionVariables.get("schema_Product"));
pm.test("Respectă schema Product din OpenAPI", function () {
    pm.response.to.have.jsonSchema(schema);
});

3. Coduri documentate. Pentru fiecare operație verifici că statusurile primite sunt dintre cele din specificație. Un 500 sau un 400 nedocumentat e o problemă de contract.

4. Cazuri negative din specificație. Câmpurile required, maxLength, enum și minimum îți dau direct testele de validare.

Diferențele găsite sunt de două tipuri: implementarea greșește sau documentația e veche. Ambele se raportează, pentru că clienții generează cod din specificație.

Ce urmărește intervievatorul: Verifică legătura dintre documentație și testare. Distincția între bug de implementare și de documentație e un plus.

94 Mid

Poți face teste de performanță cu Postman? Ce oferă și unde se oprește?

Răspuns scurt: Da, la scară mică: Collection Runner are modul Performance, care simulează utilizatori virtuali pe o perioadă și raportează timpi medii, percentile și erori. Pentru sarcini mari, scenarii complexe sau distribuite folosești k6, JMeter sau Gatling.

Postman oferă în Runner modul Performance: alegi numărul de utilizatori virtuali, durata și profilul de încărcare (fix, rampă, vârf), iar fiecare utilizator rulează colecția în buclă. Raportul arată:

  • timpul mediu și percentilele (p90, p95, p99);
  • cererile pe secundă;
  • rata de erori și pe ce cereri;
  • evoluția în timp, ca să vezi când începe degradarea.

E util pentru:

  • o verificare rapidă că un endpoint nu se prăbușește la câteva zeci de utilizatori simultani;
  • compararea înainte și după o optimizare;
  • reproducerea unei probleme de concurență (două comenzi pe ultimul produs din stoc).

Limitele:

  • sarcina pleacă de pe calculatorul tău, deci e plafonată de el și de rețeaua ta;
  • scenarii realiste (gândire între pași, date diferite per utilizator, mii de utilizatori) cer unelte dedicate: k6, JMeter, Gatling, Locust;
  • nu rulezi niciodată un test de încărcare pe producție sau pe un mediu partajat fără acordul echipei.

Mesajul important la interviu: știi ce măsori (percentile, nu medii) și când să treci la o unealtă potrivită.

Ce urmărește intervievatorul: Testează cunoașterea uneltei și a limitelor ei. Accentul pe percentile și pe acordul echipei arată maturitate.

95 Senior

Echipa de frontend lucrează pe mock-ul Postman, iar backend-ul livrează mai târziu. Cum eviți ca la integrare mock-ul și API-ul real să nu se potrivească?

Răspuns scurt: Mock-ul și backend-ul pornesc din același contract (OpenAPI), exemplele se generează sau se validează din schemă, aceeași colecție de teste rulează pe mock și pe API-ul real, iar orice schimbare de contract trece prin review comun.

Riscul e clasic: frontend-ul se adaptează la exemplele scrise de mână, backend-ul implementează altceva, iar la integrare totul se strică.

1. O singură sursă de adevăr. Contractul OpenAPI e convenit la început și stă în repository. Mock-ul se generează din el, iar backend-ul îl implementează.

2. Exemple validate. Exemplele din mock trebuie să respecte schemele. Un test simplu rulează colecția pe mock cu validare de schemă: dacă un exemplu nu respectă schema, eroarea apare devreme.

3. Aceeași suită pe ambele. Colecția are două environment-uri, „Mock” și „Dev”. Când backend-ul livrează primele endpointuri, rulezi aceleași teste pe API-ul real; diferențele ies imediat.

4. Și erorile, nu doar succesul. Mock-ul trebuie să aibă exemple pentru 401, 404, 422 și 500, cu formatul real al erorilor; altfel frontend-ul nu le tratează.

5. Schimbări controlate. Orice modificare de contract trece prin pull request văzut de ambele echipe, cu actualizarea mock-ului în același pas.

Pentru sisteme cu multe echipe, următorul pas e contract testing dedicat (de exemplu Pact), dar ideea de bază e aceeași: contractul verificat automat de ambele părți.

Ce urmărește intervievatorul: Întrebare senior despre colaborare între echipe. Se urmărește contractul unic și rularea acelorași teste pe mock și pe real.

Situații practice și comportamentale

96 Junior

Primești un API nou, fără documentație completă, și o zi ca să-l testezi. Cum îți organizezi ziua?

Răspuns scurt: Aflu ce e critic (ce folosesc clienții), explorez endpointurile principale în Postman, construiesc o colecție minimă cu teste pe fluxul principal și pe erorile evidente, notez întrebările și neclaritățile, iar la final raportez ce am acoperit și ce nu.

Un răspuns bun arată prioritizare, nu dorința de a testa tot.

Prima oră: context. Întreb ce face API-ul, cine îl folosește, ce s-a schimbat și ce ar fi cel mai grav să se strice. Caut orice sursă: specificație parțială, cod, tichete, cereri din aplicația care îl consumă (DevTools → cURL).

Explorare (2–3 ore). Construiesc colecția: environment cu baseUrl, login automat, câte o cerere pe endpointurile principale. Notez comportamentul observat și orice pare ciudat.

Teste pe ce contează (3 ore). Fluxul principal cap-coadă, validări de bază, autorizare (anonim, alt utilizator), erorile evidente. Teste automate în Post-response, ca munca să poată fi repetată.

Final: raport. Ce am testat, ce bug-uri am găsit (cu cererile atașate), ce n-am apucat și ce riscuri rămân, plus întrebările deschise pentru dezvoltatori.

Intervievatorul vrea să audă că nu dispari o zi întreagă și că transparența despre ce nu ai testat e la fel de importantă ca rezultatele.

Ce urmărește intervievatorul: Întrebare situațională despre prioritizare sub presiune. Se apreciază raportarea a ceea ce rămâne netestat.

97 Junior

Ai găsit un bug într-un API cu Postman. Ce pui în raport ca dezvoltatorul să-l poată reproduce imediat?

Răspuns scurt: Endpointul, mediul și versiunea, cererea exactă (ca cURL sau colecție exportată, fără secrete), răspunsul primit și cel așteptat cu sursa așteptării, pașii de pregătire a datelor, frecvența și impactul.

Un raport bun scutește o zi de mesaje înainte și înapoi.

Titlu clar: „POST /orders acceptă cantitate negativă și scade totalul”, nu „bug la comenzi”.

Conținut:

  • mediul: Staging, versiunea build-ului, ora (ajută la căutarea în loguri);
  • cererea exactă: din Postman, Code → cURL, sau colecția exportată cu cererea; tokenurile și parolele înlocuite cu <token>;
  • pregătirea: ce date trebuie să existe (utilizatorul Ana, coș gol);
  • răspunsul primit: status, body relevant, antete importante, eventual ID-ul de corelare din antet;
  • rezultatul așteptat și de unde vine: specificația, regula de business, comportamentul din v1;
  • frecvența: mereu sau intermitent, de câte ori din câte încercări;
  • impactul: cine e afectat și cât de grav;
  • testul automat care pică, dacă există, ca dezvoltatorul să verifice reparația cu el.

Un bonus apreciat: cazul minim. Dacă bug-ul apare cu body de 40 de câmpuri, încerci să găsești câmpul care îl provoacă și raportezi varianta redusă.

Ce urmărește intervievatorul: Verifică abilitatea de comunicare cu dezvoltatorii. Secretele eliminate din cURL și cazul minim sunt semne de profesionalism.

98 Junior

Un dezvoltator îți răspunde la un bug raportat că „nu e bug, așa a fost făcut”. Cum procedezi?

Răspuns scurt: Verific de unde vine așteptarea mea (specificație, cerință, comportament anterior). Dacă există o sursă, o arăt calm, cu exemplul concret. Dacă nu, decizia aparține product owner-ului, nu mie sau dezvoltatorului, iar rezultatul se documentează.

Situația e foarte frecventă și intervievatorul urmărește atitudinea, nu cine câștigă.

1. Verific-mă pe mine. Așteptarea mea are o sursă? Specificația OpenAPI, criteriile de acceptare, documentația, comportamentul altor endpointuri, un standard HTTP. Uneori dezvoltatorul are dreptate și eu am presupus greșit.

2. Dacă am o sursă, o arăt concret și neutru: „Specificația spune 409 pentru email duplicat, primim 500; aici e cererea din Postman.” Discuția e despre comportament, nu despre persoană.

3. Dacă nu e clar, nu e decizia noastră, a amândurora. Product owner-ul sau arhitectul decide dacă e bug, comportament acceptat sau cerință nouă. Le prezint impactul: ce vede clientul, ce risc există.

4. Documentez decizia. Dacă e „așa trebuie”, actualizez testele și propun clarificarea documentației, ca întrebarea să nu reapară. Dacă e bug, rămâne în tichet cu prioritatea stabilită.

Ce nu faci: insiști pe ton personal, redeschizi tichetul fără argumente noi sau renunți fără să întrebi pe cine trebuie.

Ce urmărește intervievatorul: Întrebare comportamentală despre conflict profesional. Se apreciază verificarea propriei așteptări și escaladarea către cine decide.

99 Mid

Povestește o situație în care testele tale de API au prins o problemă importantă înainte de producție. Ce ai făcut și ce ai învățat?

Răspuns scurt: Răspunsul urmează structura situație, sarcină, acțiune, rezultat: contextul, ce test a prins problema și de ce exista, cum ai investigat și comunicat, ce s-a schimbat după (test nou, proces), cu un rezultat concret.

Întrebarea testează dacă ai experiență reală și dacă o poți povesti clar. Structura recomandată e STAR: situație, sarcină, acțiune, rezultat.

Un exemplu de răspuns bun:

„Situație: lucram la un magazin online; înainte de o campanie de reduceri, echipa a schimbat calculul cupoanelor. Sarcină: eram responsabil de suita Postman rulată după deploy pe staging. Acțiune: testul data-driven pentru cupoane a picat pe un singur rând: la un subtotal de exact 100 de lei, reducerea nu se aplica. Am izolat cazul în Postman, am verificat regula în cerință („minimum 100 lei”, deci inclusiv), am raportat cu cererea exactă și am arătat impactul: campania promova chiar coșuri de 100 de lei. Rezultat: bug-ul, o comparație > în loc de >=, a fost reparat în aceeași zi. Am adăugat apoi teste pe toate limitele pentru reguli similare și am propus ca fiecare regulă de preț să vină cu exemple numerice în cerință.”

Ce contează: un exemplu concret, contribuția ta (nu „echipa”), un rezultat măsurabil și o lecție aplicată ulterior. Pregătește dinainte două-trei povești de acest tip.

Ce urmărește intervievatorul: Întrebare comportamentală clasică. Intervievatorul urmărește claritatea, rolul personal și ce s-a schimbat după.

100 Mid

Echipa folosește Postman doar manual, iar colecția nu e rulată nicăieri automat. Cum i-ai convinge să o integreze în CI?

Răspuns scurt: Încep mic și arăt valoare: aduc colecția la un nivel stabil, o rulez cu Newman pe staging după deploy, arăt primele bug-uri prinse și costul lor evitat. Apoi propun pasul în pipeline, cu responsabilități clare pentru eșecuri.

Schimbările de proces se câștigă cu rezultate, nu cu prezentări.

1. Pregătesc terenul. O colecție care rulează întreagă, fără intervenție manuală: login automat, date proprii, fără dependențe de ordine, fără teste instabile. Altfel primul pipeline roșu fals îngroapă ideea.

2. Rulez singur, o perioadă. Un job neblocant (sau chiar de pe calculatorul meu, programat) după fiecare deploy pe staging. Notez ce prinde.

3. Arăt valoarea. După două-trei săptămâni am exemple: „aceste trei regresii au fost prinse în 5 minute după deploy, nu de clienți”. Costul e concret: rularea durează 4 minute.

4. Propun pasul următor, cu răspunsuri la temeri: cine repară când pică (cine a stricat, cu ajutorul QA), ce facem cu testele instabile (carantină cu termen), cât durează.

5. Fac ușor de adoptat. Colecția în repository, documentația de rulare locală într-un README, rapoarte clare în pipeline.

Apoi, după ce funcționează pe staging, se poate discuta despre pull request-uri. Intervievatorul vrea să vadă că înțelegi că încrederea se construiește treptat.

Ce urmărește intervievatorul: Întrebare despre influență fără autoritate. Se apreciază abordarea incrementală și grija pentru teste stabile înainte de a le face blocante.

Î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 Postman, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Postman scriind cod, nu doar citind

Curs API Testing cu Postman: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 10 lecții sunt gratuite.