Scrii teste pentru bariera unei parcări: prima jumătate de oră e gratuită, apoi fiecare oră începută costă 5 lei, iar plata trece printr-un serviciu extern. La final, Maven rulează nouă teste și îți spune că toate trec:
mvn test, fragment din terminal
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.057 s -- in ro.exemplu.parcare.ParcareTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.402 s -- in ro.exemplu.parcare.BarieraTest
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.004 s -- in ro.exemplu.parcare.BarieraCazuriTest
[INFO] Tests run: 9, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
Un test e o metodă care rulează o bucată din programul tău și verifică rezultatul. Îl scrii o dată și îl rulezi de câte ori vrei, în câteva secunde, după fiecare schimbare.
Codul testat are două clase. Parcare calculează taxa, iar Bariera o cere și încasează banii prin interfața Plati:
să scrii un test JUnit 5 în trei timpi: Arrange, Act, Assert
să verifici rezultate cu assertEquals și excepții cu assertThrows
să rulezi același test pe mai multe date, cu @ParameterizedTest
să înlocuiești serviciul de plăți cu un mock Mockito și să verifici apelurile
Pasul 2 din 5
Urmărește un test cu mock
Testul de mai jos verifică ieșirea unei mașini care a stat 90 de minute. Banca adevărată nu e implicată: în locul ei e un mock, un obiect fals pe care îl programezi tu. Apasă pe „Linia următoare”.
Linia 9. Pentru fiecare metodă @Test, JUnit creează un obiect nou din clasa de test. Câmpurile se inițializează din nou, deci fiecare test primește un mock curat. mock(Plati.class) face un obiect care implementează interfața, dar nu face nimic: metodele lui întorc false, 0 sau null.
Linia 10. Bariera adevărată primește o Parcare reală și mock-ul. Nu știe că plățile sunt false: vede doar interfața Plati.
Linia 16. Arrange: programezi mock-ul. Dacă cineva cere incaseaza("B 12 ABC", 10), mock-ul răspunde true. Pentru alte argumente ar răspunde tot false.
Linia 19. Act: apelezi metoda testată. Parcare calculează 90 de minute = 2 ore începute = 10 lei, iar bariera cere plata. Mock-ul recunoaște argumentele și întoarce true, deci r primește „Plătit 10 lei”.
Linia 22. Assert: assertEquals(așteptat, real) compară cele două texte. Sunt egale, deci testul merge mai departe.
Linia 23.verify întreabă mock-ul dacă a primit exact apelul incaseaza("B 12 ABC", 10), o singură dată. L-a primit, așa că și această verificare trece.
Gata. Metoda s-a terminat fără nicio aserțiune picată, deci JUnit marchează testul ca trecut.
Prezice rezultatul
Ștergi liniile 16 și 17, deci mock-ul nu mai e programat. Ce primește r la linia 19?
Răspuns: "Plată refuzată".
O metodă neprogramată a unui mock întoarce valoarea implicită a tipului: false pentru boolean. Bariera crede că plata a eșuat. Testul pică la linia 22, cu expected: <Plătit 10 lei> but was: <Plată refuzată>.
Pasul 3 din 5
Cum se scrie un test bun
Trei idei: testul simplu, testul pe mai multe date și mock-ul verificat. Apoi două capcane, cu mesajele reale din mvn test.
Testele stau în src/test/java, în același pachet cu clasa testată. Numele metodei spune ce comportament verifici, ca o propoziție: primele30DeMinuteSuntGratis.
Arrange pregătește datele, Act rulează o singură acțiune, Assert verifică rezultatul. @BeforeEach rulează înaintea fiecărui test, deci fiecare primește o Parcare nouă și nu moștenește nimic de la testul de dinainte.
2
Mai multe date, aceeași regulă
În același fișier, @ParameterizedTest cu @CsvSource rulează metoda o dată pentru fiecare pereche: 31 de minute costă 5 lei, 60 tot 5, iar 61 deja 10. De aceea Maven raportează 5 teste în ParcareTest, deși clasa are doar trei metode.
Valorile de la margine, ca 30, 31, 60 și 61, sunt cele mai valoroase: acolo greșesc de obicei calculele cu „mai mic” și „mai mic sau egal”.
assertThrows primește tipul excepției și o lambda cu codul care trebuie să o arunce. Testul trece doar dacă excepția chiar apare.
verify(plati, never()) cere ca metoda să nu fi fost apelată deloc: la 20 de minute nu se plătește nimic, deci nici serviciul de plăți nu trebuie deranjat. anyString() și anyInt() acceptă orice argument.
ArgumentCaptor prinde valoarea trimisă mock-ului, ca s-o verifici separat: 150 de minute înseamnă 3 ore începute, deci 15 lei. În ultimul test mock-ul nu e programat, întoarce false și bariera refuză ieșirea.
Capcană: așteptarea greșită
Pare logic că o oră și jumătate costă 5 lei. Codul socotește însă orele începute, deci 10. Testul pică, iar Maven arată exact linia și cele două valori:
[ERROR] ro.exemplu.parcare.OraGresitTest.oraSiJumatate -- Time elapsed: 0.002 s <<< FAILURE!
org.opentest4j.AssertionFailedError: expected: <5> but was: <10>
at ro.exemplu.parcare.OraGresitTest.oraSiJumatate(OraGresitTest.java:11)
Repară decizia, nu testul la întâmplare: dacă regula e „ora începută”, așteptarea corectă e 10. Și păstrează ordinea assertEquals(așteptat, real), altfel mesajul îți inversează valorile.
Capcană: programezi ce nu se folosește
Cu MockitoExtension, Mockito e strict: dacă programezi un apel care nu are loc, testul pică. Aici mașina stă 20 de minute, taxa e 0, iar plata nu e cerută niciodată:
org.mockito.exceptions.misusing.UnnecessaryStubbingException:
Unnecessary stubbings detected.
Clean & maintainable test code requires zero unnecessary code.
Following stubbings are unnecessary (click to navigate to relevant line of code):
1. -> at ro.exemplu.parcare.StubInutilTest.parcareScurta(StubInutilTest.java:17)
Repară ștergând when(…) și verificând ce contează: verify(plati, never()). Eroarea te ajută, pentru că un stub inutil arată de obicei un test care nu mai verifică ce crezi tu.
Pasul 4 din 5
Verifică-te
Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.
1 din 5 · Prezice rezultatul
Ce raportează mvn test pentru acest test parametrizat?
Q1Test.java
package ro.exemplu.parcare;import static org.junit.jupiter.api.Assertions.*;import org.junit.jupiter.params.*;import org.junit.jupiter.params.provider.*;class Q1Test {@ParameterizedTest@CsvSource({"30, 0", "90, 10", "121, 10"})voidtaxe(int minute, int lei) { Parcare p = new Parcare(); assertEquals(lei, p.taxa(minute)); }}
Răspuns: trei teste, unul pică.
Fiecare rând din @CsvSource e un test separat. 121 de minute înseamnă 3 ore începute, adică 15 lei, nu 10. Primele două rânduri trec.
2 din 5 · Alege varianta
Ai un mock plati pe care nu l-ai programat cu when. Ce întoarce plati.incaseaza("X", 5)?
Răspuns: false.
Mock-urile întorc valoarea implicită a tipului: false, 0, null sau o listă goală. Nu aruncă nimic, decât dacă le programezi cu thenThrow.
3 din 5 · Prezice rezultatul
Mașina a stat 90 de minute. Ce se întâmplă la verify?
verify compară și argumentele. Bariera a cerut 10 lei, testul se aștepta la 5. Mockito arată ambele apeluri: Wanted: plati.incaseaza("B 12 ABC", 5) și Actual: plati.incaseaza("B 12 ABC", 10). Nu e niciun when, deci nu poate fi vorba de un stub inutil.
4 din 5 · Alege varianta
Care linie verifică corect că taxa(-5) aruncă IllegalArgumentException?
Răspuns: varianta cu lambda.
assertThrows trebuie să ruleze el codul, ca să prindă excepția; de aceea primește o lambda. Fără () ->, ar primi rezultatul apelului, un int, nu codul de rulat; varianta nici nu se compilează.
5 din 5 · Alege varianta
De ce folosești un mock pentru Plati în testele barierei?
Răspuns: ca să testezi doar bariera.
Un test unitar verifică o singură clasă. Mock-ul îți dă controlul total: alegi tu dacă plata trece sau nu și verifici exact ce i s-a cerut, în câteva milisecunde.
Pasul 5 din 5
Ce ai învățat
Un test JUnit e o metodă @Test cu trei timpi: Arrange, Act, Assert.
assertEquals(așteptat, real), assertThrows cu lambda și @ParameterizedTest acoperă majoritatea cazurilor.
Un mock înlocuiește o dependență: îl programezi cu when(…).thenReturn(…), altfel întoarce valori implicite.
verify, never() și ArgumentCaptor verifică ce a primit mock-ul.
Proiectul complet
Ai nevoie de două dependențe în pom.xml. mockito-junit-jupiter aduce și Mockito, iar junit-jupiter aduce și testele parametrizate:
Pune fișierele din lecție în src/main/java/ro/exemplu/parcare și src/test/java/ro/exemplu/parcare, apoi rulează mvn test. Pe Java 21 și mai nou, Mockito afișează un avertisment că se atașează singur ca agent; testele merg, iar în proiectele mari se configurează ca agent în Maven.