Rezolvarea unei provocări de tip scriere de teste

Unele provocări DojoCode îți cer să scrii teste în loc de cod. Implementarea există deja și este corectă. Rolul tău este să scrii o suită de teste suficient de bună încât să observe când acea implementare se strică. 🕵️

Poți recunoaște o provocare de tip scriere de teste după indiciul albastru deasupra descrierii:

Cum rezolvi: soluția de referință e corectă, citește-o. Scrie teste care verifică ce face, inclusiv cazurile limită și erorile. „Rulează testele” le verifică pe soluția corectă; „Verifică testele” le rulează și pe copii ascunse, fiecare cu câte un bug. Trimite când testele tale prind toate bug-urile ascunse.

Cum funcționează

În culise, autorul provocării a pregătit câteva bug-uri ascunse: copii ale soluției de referință, fiecare cu câte un mic bug, cum ar fi o limită greșită, o validare lipsă sau o valoare incorectă. Când verifici sau trimiți testele, DojoCode le verifică în doi pași:

1. Pe soluția corectă. Toate testele tale trebuie să treacă. Un test care eșuează pe codul corect este un test greșit.
2. Pe fiecare bug ascuns. Pentru fiecare copie cu bug, cel puțin unul dintre testele tale trebuie să eșueze. Când se întâmplă asta, bug-ul este prins.

Completezi provocarea atunci când testele tale trec pe soluția corectă și prind fiecare bug ascuns.

Nu cunoști bug-urile ascunse dinainte, și exact asta e ideea: trebuie să te gândești cum s-ar putea strica codul. Citește soluția de referință și testează tot ce promite, inclusiv cazurile limită și erorile.

Bara de acțiuni are un buton pentru fiecare etapă a muncii tale:

Buton	Ce rulează
Run Tests (Rulează testele)	Doar testele tale pe soluția corectă, cu rezultatul fiecărui test.
Verify tests (Verifică testele)	Testele tale pe bug-urile ascunse, cu rezultatul pentru fiecare bug, fără a trimite.
Submit (Trimite)	Ambii pași de mai sus, iar rezultatul contează pentru scorul tău.

Spațiul de lucru

Fig. 1 - Provocarea Add Numbers: Write the Tests: add.js este blocat, testul de pornire este deschis, iar indiciul deasupra descrierii explică modul de rezolvare

• Soluția de referință este vizibilă și marcată cu un lacăt 🔒. Citește-o cu atenție: este comportamentul pe care testele tale trebuie să îl descrie. Nu o poți edita, iar un fișier pe care îl creezi la aceeași cale este ignorat atunci când rulează testele tale.
• Testul de pornire este fișierul în care lucrezi. Conține deja un test care trece, ca să arate structura și importurile. Adaugă propriile teste alături de el sau creează fișiere de test noi.
• Fișierul principal (marcat cu ▶) este punctul de intrare pentru Run, atunci când șablonul are unul. Folosește Run ca să apelezi soluția de referință și să afișezi valori în timp ce o explorezi.

Rularea testelor tale

Apasă pe Run Tests ca să rulezi testele tale doar pe soluția corectă. Panoul de rezultate arată aceleași rezultate ca la o provocare clasică: un rezumat al testelor trecute și eșuate, rezultatul fiecărui test, ieșirea din consolă și eventualele erori. Bug-urile ascunse nu sunt verificate, așa că poți folosi Run Tests ori de câte ori vrei în timp ce scrii și depanezi testele.

Fig. 2 - Run Tests rulează testul de pornire și un test nou pentru numere negative doar pe soluția corectă: ambele trec, iar ieșirea console.log apare sub Log.

Fiecare test trebuie să treacă aici. Un test care eșuează pe soluția corectă se așteaptă la un comportament greșit: corectează așteptarea astfel încât să se potrivească cu ce face cu adevărat soluția de referință. Apasă pe What did I do wrong? ca să primești o explicație de la asistentul AI.

Verificarea testelor tale

Apasă pe Verify tests ca să-ți verifici testele pe bug-urile ascunse, fără a trimite. Panoul de rezultate afișează:

• Un rezumat cu testele tale trecute și eșuate, bug-urile ascunse prinse (de exemplu Bugs caught: 1/3) și durata.
• Un verdict pe o singură linie, urmat de o scurtă reamintire a modului în care funcționează verificarea.
• Hidden bugs caught (Bug-uri ascunse prinse): câte o linie pentru fiecare bug ascuns.

Testele tale rulează în continuare mai întâi pe soluția corectă, la fel ca la Submit, dar o rulare reușită nu mai este listată încă o dată: ai văzut-o deja cu Run Tests. Panoul de rezultate afișează unul dintre cele trei rezultate posibile.

Testele tale eșuează pe soluția corectă

Fig. 3 - Testul se așteaptă la 6 pentru add(2, 3), așa că eșuează pe implementarea corectă. Testul care eșuează este listat, iar bug-urile ascunse sunt sărite până când trec toate testele.

Verdictul este Your tests fail on the correct solution. Acesta e singurul caz în care Verify tests îți listează testele: testele care eșuează sunt ale tale, rulate pe cod corect, deci testul e greșit, nu implementarea. Hidden bugs afișează Skipped until all your tests pass on the correct solution: bug-urile ascunse sunt verificate doar după ce trec toate testele.

Repară mai întâi testele care eșuează: așteptările tale trebuie să corespundă cu ce face cu adevărat soluția de referință. Folosește Run Tests în timp ce le repari, apoi verifică din nou.

Testele tale ratează unele bug-uri ascunse

Fig. 4 - Doar testul de pornire este scris: trece pe soluția corectă și prinde un bug, iar două bug-uri ascunse rămân neprinse, fiecare cu un indiciu despre comportamentul de testat.

Verdictul este Your tests missed 2 of 3 hidden bugs. În lista de bug-uri ascunse:

• Un bug prins (bifă verde) își afișează numele, o descriere a bug-ului și Caught by, adică numele testelor tale care au eșuat pe el. Așa vezi ce protejează fiecare dintre testele tale.
• Un bug ratat (cruce roșie) rămâne ascuns: apare doar ca Hidden bug #N, cu reamintirea că toate testele tale încă trec pe acea copie cu bug și un Hint (indiciu) care numește comportamentul de testat, de exemplu Negative numbers, fără să-ți spună care e bug-ul. Numele și descrierea lui apar după ce testele tale îl prind.

Adaugă un test care fixează exact comportamentul din indiciu, apoi verifică din nou.

În exemplul de mai sus, singurul test este expect(add(2, 3)).toBe(5). El prinde bug-ul care adaugă unu la fiecare rezultat. Celelalte două rămân neprinse: cu două numere pozitive, un bug la tratarea numerelor negative nu schimbă nimic, iar niciun test nu trimite un șir de caractere. Adăugând expect(add(-2, -3)).toBe(-5) și expect(() => add('1', 2)).toThrow(TypeError), le prinzi pe amândouă.

Toate bug-urile ascunse sunt prinse

Când testele tale trec pe soluția corectă și fiecare bug ascuns are o bifă verde, verdictul este All N hidden bugs caught. Great tests!, unde N este numărul de bug-uri ascunse. Ești gata să trimiți.

Trimiterea

Apasă pe Submit ca să-ți trimiți testele pentru verificarea finală. Trimiterea îți rulează testele pe soluția corectă și pe fiecare bug ascuns, afișează ambele liste, iar rezultatul contează ca la orice altă provocare: se aplică XP, seriile de zile (streaks), progresul la concurs și insignele.

Fiecare bug ascuns contează ca un test ascuns în plus în scorul tău. Un bug ratat contează ca un test eșuat, așa că o rulare reușită doar pe soluția corectă nu înseamnă niciodată 100%.

Sfaturi ca să prinzi fiecare bug

• Testează limitele. Majoritatea bug-urilor ascunse stau la margini: intrare goală, zero, primul și ultimul element, limita exactă a unui interval.
• Testează erorile. Dacă soluția de referință aruncă o excepție, respinge o cerere sau dezactivează un buton, verifică asta în test. O validare lipsă este un bug ascuns clasic.
• Verifică valori exacte. toEqual('Hello World!') prinde mult mai multe decât toBeTruthy() sau o verificare de tip.
• Alege date de intrare relevante. Alege date de intrare la care un bug s-ar vedea. add(2, 3) nu poate scoate la iveală un bug cu numere negative, add(-2, -3) poate.
• Învață din ce ai prins. Caught by arată ce test a prins fiecare bug. Un test care nu prinde nimic s-ar putea să verifice prea puțin.
• Urmează indiciile. Un indiciu numește un comportament, nu o valoare: testează-l cu mai multe date de intrare, inclusiv cazurile limită.
• Întâi testează, apoi verifică. Folosește Run Tests pentru feedback rapid la fiecare test în timp ce scrii și Verify tests după ce testele tale trec, ca să vezi ce bug-uri ascunse prind.

Pagini similare

• 🥋 Rezolvarea unei provocări
• 🧪 Provocări de scriere de teste: cum construiesc autorii aceste provocări
• 📚 Exemple de scriere de teste după șablon