MyCodeSchool

Pasul 1 din 5

Java

Pasul 1 din 5 · Ce construiești

  • Java
  • Mediu
  • 14 minute

Teste automate cu JUnit 5 și Mockito

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:

Bariera.java
package ro.exemplu.parcare;public class Bariera {    private final Parcare parcare;    private final Plati plati;    public Bariera(Parcare parcare,                   Plati plati) {        this.parcare = parcare;        this.plati = plati;    }    public String iesire(String numar,                         int minute) {        int lei = parcare.taxa(minute);        if (lei == 0) {            return "Drum bun";        }        if (plati.incaseaza(numar, lei)) {            return "Plătit " + lei + " lei";        }        return "Plată refuzată";    }}

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”.

BarieraTest.java
package ro.exemplu.parcare;import static org.junit.jupiter.api.Assertions.*;import static org.mockito.Mockito.*;import org.junit.jupiter.api.Test;class BarieraTest {    Plati plati = mock(Plati.class);    Bariera bariera =            new Bariera(new Parcare(), plati);    @Test    void incaseazaLaIesire() {        // Arrange        when(plati.incaseaza("B 12 ABC", 10))                .thenReturn(true);        // Act        String r =                bariera.iesire("B 12 ABC", 90);        // Assert        assertEquals("Plătit 10 lei", r);        verify(plati)                .incaseaza("B 12 ABC", 10);    }}

Obiecte în test

Rezultatul testului


      

  1. 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.
  2. 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.
  3. 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.
  4. 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”.
  5. Linia 22. Assert: assertEquals(așteptat, real) compară cele două texte. Sunt egale, deci testul merge mai departe.
  6. 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.
  7. 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.

Un test, trei timpi

Parcare.java
package ro.exemplu.parcare;public class Parcare {    public int taxa(int minute) {        if (minute < 0) {            throw new IllegalArgumentException(                    "minute negative");        }        if (minute <= 30) {            return 0;        }        int ore = (minute + 59) / 60;        return ore * 5;    }}
ParcareTest.java
package ro.exemplu.parcare;import static org.junit.jupiter.api.Assertions.*;import org.junit.jupiter.api.*;import org.junit.jupiter.params.*;import org.junit.jupiter.params.provider.*;class ParcareTest {    private Parcare parcare;    @BeforeEach    void pregateste() {        parcare = new Parcare();    }    @Test    void primele30DeMinuteSuntGratis() {        // Arrange        int minute = 30;        // Act        int lei = parcare.taxa(minute);        // Assert        assertEquals(0, lei);    }    @ParameterizedTest    @CsvSource({"31, 5", "60, 5", "61, 10"})    void oraIncepututaSePlateste(            int minute, int asteptat) {        assertEquals(asteptat,                parcare.taxa(minute));    }    @Test    void minuteleNegativeSuntRespinse() {        assertThrows(                IllegalArgumentException.class,                () -> parcare.taxa(-1));    }}

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.

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.

Ce a primit mock-ul

BarieraCazuriTest.java
package ro.exemplu.parcare;import static org.junit.jupiter.api.Assertions.*;import static org.mockito.Mockito.*;import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;class BarieraCazuriTest {    Plati plati = mock(Plati.class);    Bariera bariera =            new Bariera(new Parcare(), plati);    @Test    void faraTaxaNuCheamaPlata() {        bariera.iesire("CJ 07 XYZ", 20);        verify(plati, never())                .incaseaza(anyString(), anyInt());    }    @Test    void trimiteSumaCorecta() {        bariera.iesire("IS 01 AAA", 150);        var suma = ArgumentCaptor                .forClass(Integer.class);        verify(plati).incaseaza(                eq("IS 01 AAA"), suma.capture());        assertEquals(15, suma.getValue());    }    @Test    void plataRefuzata() {        String r =                bariera.iesire("B 12 ABC", 45);        assertEquals("Plată refuzată", r);    }}

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:

OraGresitTest.java
package ro.exemplu.parcare;import static org.junit.jupiter.api.Assertions.*;import org.junit.jupiter.api.Test;class OraGresitTest {    @Test    void oraSiJumatate() {        Parcare parcare = new Parcare();        assertEquals(5, parcare.taxa(90));    }}
[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ă:

StubInutilTest.java
package ro.exemplu.parcare;import static org.mockito.Mockito.*;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;import org.mockito.Mock;import org.mockito.junit.jupiter.MockitoExtension;@ExtendWith(MockitoExtension.class)class StubInutilTest {    @Mock    Plati plati;    @Test    void parcareScurta() {        when(plati.incaseaza("B 12 ABC", 5))                .thenReturn(true);        Bariera b = new Bariera(new Parcare(), plati);        b.iesire("B 12 ABC", 20);    }}
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"})    void taxe(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?

Q3Test.java
package ro.exemplu.parcare;import static org.mockito.Mockito.*;import org.junit.jupiter.api.Test;class Q3Test {    @Test    void verificaSuma() {        Plati plati = mock(Plati.class);        Bariera b =                new Bariera(new Parcare(), plati);        b.iesire("B 12 ABC", 90);        verify(plati)                .incaseaza("B 12 ABC", 5);    }}

Răspuns: pică, argumentele diferă.

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

Proiectul complet

Ai nevoie de două dependențe în pom.xml. mockito-junit-jupiter aduce și Mockito, iar junit-jupiter aduce și testele parametrizate:

pom.xml
<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">  <modelVersion>4.0.0</modelVersion>  <groupId>ro.exemplu</groupId>  <artifactId>parcare</artifactId>  <version>1.0</version>  <properties>    <maven.compiler.release>25</maven.compiler.release>    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  </properties>  <dependencies>    <dependency>      <groupId>org.junit.jupiter</groupId>      <artifactId>junit-jupiter</artifactId>      <version>5.13.4</version>      <scope>test</scope>    </dependency>    <dependency>      <groupId>org.mockito</groupId>      <artifactId>mockito-junit-jupiter</artifactId>      <version>5.20.0</version>      <scope>test</scope>    </dependency>  </dependencies>  <build>    <plugins>      <plugin>        <groupId>org.apache.maven.plugins</groupId>        <artifactId>maven-compiler-plugin</artifactId>        <version>3.14.1</version>      </plugin>      <plugin>        <groupId>org.apache.maven.plugins</groupId>        <artifactId>maven-surefire-plugin</artifactId>        <version>3.5.4</version>      </plugin>    </plugins>  </build></project>

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.

Continuă cu