Testare Software

Parcurs: Intermediar · lecția 2 din 19

IntermediarAutomatizare7 min de cititActualizat 12 noiembrie 2026

Piramida testelor în practică

E ușor să cunoști piramida. Ca s-o aplici ai nevoie de dubluri de test în care să ai încredere, de teste de contract între servicii, de o formă potrivită arhitecturii tale și de un pipeline care dă feedback rapid. Iată cum.

Pe această pagină

De reținut

  • Straturile de jos depind de dubluri de test (stub-uri, mock-uri, fake-uri). Fac testele rapide, dar se pot îndepărta de realitate, așa că ceva trebuie să le verifice față de sistemul real.
  • Testele de contract verifică dacă serviciile se înțeleg asupra API-ului fără să le rulezi împreună. Înlocuiesc multe teste end-to-end lente.
  • Forma potrivită depinde de arhitectură: o piramidă, un fagure (honeycomb) pentru microservicii sau un trofeu (trophy) pentru front-end. Împarte testele pe etape în pipeline și măsoară sănătatea suitei ca să-și păstreze forma.

De unde pornim

Articolul presupune că știi cele trei straturi ale piramidei și de ce vrei multe teste rapide la bază. Aici ne uităm la ce o face să funcționeze într-un cod real și ce faci când nu funcționează.

Dublurile de test: cum rămân rapide straturile de jos

Un test unitar pentru codul de checkout n-ar trebui să apeleze procesatorul real de plăți. În schimb, folosește o dublură de test (test double): un înlocuitor pentru dependența reală. Gerard Meszaros a numit tipurile uzuale în xUnit Test Patterns (2007):

DublurăCe faceExemplu
DummyOcupă un parametru; nu e folosit niciodatăUn obiect client gol, transmis doar ca să se potrivească semnătura funcției
StubÎntoarce răspunsuri fixeUn serviciu de prețuri care întoarce mereu 100,00
FakeO versiune simplă, dar funcționalăO bază de date în memorie în locul uneia reale
SpyÎnregistrează cum a fost apelatNumără câte e-mailuri au fost „trimise”
MockAșteaptă apeluri anume și pică testul dacă nu au locPică dacă charge(149.90) nu e apelat exact o dată

Riscul: dubluri care mint

O dublură e la fel de corectă ca presupunerile din spatele ei. Dacă API-ul real de plăți redenumește un câmp, fiecare stub al lui continuă să întoarcă vechiul câmp. Testele unitare rămân verzi, iar producția se strică.

Două obiceiuri țin dublurile oneste:

  • Verifică dublurile față de realitate. Orice dublură importantă are nevoie de cel puțin un test de integrare sau de contract care confirmă că sistemul real se comportă la fel.
  • Nu folosi mock-uri unde nu e nevoie. Testele pline de mock-uri doar repetă implementarea: verifică cum funcționează codul, nu ce face, și se strică la fiecare refactorizare.

Testele de contract: integrare fără tot sistemul

Într-un sistem format din servicii, testele end-to-end care pornesc totul împreună sunt lente și fragile. Testele de contract verifică, în schimb, înțelegerea dintre două servicii.

Cu contracte conduse de consumator (consumer-driven contracts), abordarea popularizată de unealta Pact:

  1. Consumatorul își scrie așteptările. Testele serviciului de checkout spun: „Când cer prețul produsului 42, aștept un câmp price cu un număr.”
  2. Aceste așteptări devin un contract, un fișier pe care îl primește echipa furnizorului.
  3. Furnizorul verifică contractul pe codul său real, în propriul pipeline, fără să pornească serviciul de checkout.
  4. Dacă furnizorul încalcă contractul, de exemplu redenumind price în amount, build-ul lui pică înainte de deploy.

Fiecare serviciu își testează partea singur și rapid. Împreună, contractele acoperă integrarea care altfel ar avea nevoie de teste end-to-end lente. Pentru contracte între multe echipe și servicii, vezi Testarea de contract pentru microservicii.

Forma depinde de arhitectură

Piramida a fost descrisă pentru aplicațiile obișnuite ale vremii ei. Două alternative discutate pe larg o adaptează altor arhitecturi:

  • Fagurele de testare (testing honeycomb). Într-un articol din 2018, echipa de inginerie Spotify susținea că, pentru microservicii, majoritatea testelor ar trebui să verifice fiecare serviciu prin API-ul său, cu dependențe reale precum propria bază de date. Păstrau puține teste pentru detaliile interne de implementare și cât mai puține teste care depind de corectitudinea altor servicii.
  • Trofeul de testare (testing trophy). Kent C. Dodds a propus această formă pentru aplicațiile front-end, tot în 2018. Adaugă analiza statică (verificarea tipurilor, linting) ca bază și face din testele de integrare cel mai mare strat, testând componentele împreună, așa cum le folosesc utilizatorii.
FormăCel mai mare stratSe potrivește cel mai bine
PiramidăUnitarAplicații cu multă logică de business în cod
FagureIntegrare la nivel de serviciuMicroservicii, unde cel mai mare risc e în conexiuni
TrofeuIntegrare (plus analiză statică)Aplicații front-end construite din componente UI

Împarte testele pe etape în pipeline

Nu orice test trebuie să ruleze la fiecare schimbare. Ordonează-le după viteză, ca programatorii să primească feedback repede:

EtapăCe ruleazăȚintă
La fiecare commit sau pull requestAnaliză statică, teste unitare, teste rapide de integrare și de contractCâteva minute
După merge în ramura principalăTeste de integrare mai largi, o suită mică de smoke end-to-endSub o jumătate de oră
Programat (noaptea sau înainte de lansare)End-to-end complet, mai multe browsere, performanță, scanări de securitateSunt acceptabile și câteva ore

Un eșec într-o etapă timpurie le oprește pe cele de după. Economisește timp și îi trimite pe programatori întâi la eșecul cel mai ieftin de investigat.

Măsoară sănătatea suitei

Nu poți păstra forma fără s-o urmărești. Cifre utile:

  • Timpul de feedback pentru un pull request. Dacă tot crește, programatorii nu-l mai așteaptă.
  • Rata de instabilitate: cât de des pică testele și apoi trec fără nicio schimbare de cod. Vezi Teste instabile.
  • Timpul de diagnosticare a unui eșec. Investigațiile lungi înseamnă adesea prea multe verificări în vârf.
  • Bug-urile scăpate, pe straturi: pentru fiecare bug găsit în producție, ce strat ar fi trebuit să-l prindă? Tiparele arată unde e suita subțire.

De la cornetul de înghețată la piramidă

Exemplu realDe la o suită de 3 ore la 12 minute

Verificările de lansare ale unei echipe erau 400 de teste în browser, care durau aproximativ 3 ore. Majoritatea eșecurilor s-au dovedit probleme de sincronizare, nu bug-uri, așa că oamenii rerulau suita „să vedem dacă trece de data asta”.

Au etichetat fiecare test după ce verifica de fapt. Cele mai multe verificau reguli de business, precum calculul prețurilor, prin UI.

Au mutat aceste verificări în teste unitare și de API, au adăugat teste de contract pentru cele două servicii de care depinde checkout-ul și au păstrat aproximativ 40 de teste în browser pentru parcursurile critice ale utilizatorilor. Suita rulează acum în aproximativ 12 minute, la fiecare pull request.

Lecția: soluția n-a fost să șteargă teste. A fost să mute fiecare verificare la cel mai de jos strat care poate prinde aceeași problemă.

Ca să faci la fel:

  1. Inventariază stratul de sus. Pentru fiecare test end-to-end, notează regula sau riscul pe care îl verifică de fapt.
  2. Găsește ce poate coborî. Calculele, validările și permisiunile își au locul, de obicei, în teste unitare sau de API.
  3. Acoperă conexiunile cu contracte acolo unde se întâlnesc serviciile.
  4. Elimină duplicatele după ce testele de la nivelurile de jos există și au prins deja probleme reale.
  5. Păstrează o listă scurtă de parcursuri critice end-to-end: înregistrare, checkout, ce nu are voie să se strice niciodată.
  6. Urmărește cifrele de mai sus, ca să nu crească la loc cornetul.

Așa da

Să înlocuiești procesatorul real de plăți cu un stub în testele unitare și să adaugi un test de contract sau de integrare care verifică dacă presupunerile stub-ului se potrivesc încă cu API-ul real.

Așa nu

Să faci mock la fiecare colaborator, în fiecare test. Testele vor trece, se vor strica la fiecare refactorizare și tot vor rata bug-urile de integrare care contează.

Verifică-te

Serviciul tău de checkout apelează un serviciu de prețuri deținut de altă echipă. Un test end-to-end pică de fiecare dată când serviciul de prețuri își schimbă API-ul. Ce ai adăuga și ce ai păstra?

Arată răspunsul

Ai adăuga teste de contract conduse de consumator: checkout-ul înregistrează ce așteaptă de la serviciul de prețuri, iar acesta verifică contractul în propriul pipeline, așa că o schimbare incompatibilă pică build-ul lor înainte de deploy. În testele proprii ale checkout-ului, folosești un stub pentru prețuri. Păstrezi un singur test smoke end-to-end pentru tot parcursul de cumpărare.