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 face | Exemplu |
|---|---|---|
| Dummy | Ocupă un parametru; nu e folosit niciodată | Un obiect client gol, transmis doar ca să se potrivească semnătura funcției |
| Stub | Întoarce răspunsuri fixe | Un serviciu de prețuri care întoarce mereu 100,00 |
| Fake | O versiune simplă, dar funcțională | O bază de date în memorie în locul uneia reale |
| Spy | Înregistrează cum a fost apelat | Numără câte e-mailuri au fost „trimise” |
| Mock | Așteaptă apeluri anume și pică testul dacă nu au loc | Pică 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:
- Consumatorul își scrie așteptările. Testele serviciului de checkout spun: „Când cer prețul produsului 42, aștept un câmp
pricecu un număr.” - Aceste așteptări devin un contract, un fișier pe care îl primește echipa furnizorului.
- Furnizorul verifică contractul pe codul său real, în propriul pipeline, fără să pornească serviciul de checkout.
- Dacă furnizorul încalcă contractul, de exemplu redenumind
priceînamount, 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 strat | Se potrivește cel mai bine |
|---|---|---|
| Piramidă | Unitar | Aplicații cu multă logică de business în cod |
| Fagure | Integrare la nivel de serviciu | Microservicii, unde cel mai mare risc e în conexiuni |
| Trofeu | Integrare (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 request | Analiză statică, teste unitare, teste rapide de integrare și de contract | Câteva minute |
| După merge în ramura principală | Teste de integrare mai largi, o suită mică de smoke end-to-end | Sub o jumătate de oră |
| Programat (noaptea sau înainte de lansare) | End-to-end complet, mai multe browsere, performanță, scanări de securitate | Sunt 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ă
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:
- Inventariază stratul de sus. Pentru fiecare test end-to-end, notează regula sau riscul pe care îl verifică de fapt.
- Găsește ce poate coborî. Calculele, validările și permisiunile își au locul, de obicei, în teste unitare sau de API.
- Acoperă conexiunile cu contracte acolo unde se întâlnesc serviciile.
- Elimină duplicatele după ce testele de la nivelurile de jos există și au prins deja probleme reale.
- Păstrează o listă scurtă de parcursuri critice end-to-end: înregistrare, checkout, ce nu are voie să se strice niciodată.
- 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.
