JUnit: ce este, concepte cheie și cum funcționează

Ce este JUnit?

JUnit este un framework open-source pentru scrierea și rularea de teste unitare repetabile în limbajele Java și Kotlin. Face parte din ecosistemul xUnit — o familie de framework-uri bazate pe arhitectura lui Kent Beck și Erich Gamma și este instrumentul standard de testare în Android Studio și IntelliJ IDEA.

Sarcina principală a JUnit este de a izola un fragment mic de cod (metodă, clasă) și de a verifica comportamentul acestuia în condiții controlate. Testele sunt scrise ca clase obişuite Java/Kotlin cu adnotări, iar framework-ul se ocupă de detectarea testelor, gestionarea ciclului lor de viață și colectarea statisticilor de execuție.

Prima versiune a JUnit a apărut în 1997 și a schimbat radical abordarea dezvoltării, popularizând practicile Test-Driven Development (TDD). Astăzi, JUnit 5 (Jupiter) este versiunea curentă, complet reproiectată cu o arhitectură modulară și suport pentru Java 8+ și extensii.

Cum funcționează JUnit

Mecanismul de execuție JUnit se bazează pe modelul Test Runner, care scanează classpath-ul, găsește metodele cu adnotarea @Test, creează o instanță a clasei de test și rulează metodele într-o anumită ordine. Test Runner gestionează ciclul de viață: apel BeforeAll → BeforeEach → Test → AfterEach → AfterAll.

Ciclul de viață al clasei de test

JUnit înfășoară fiecare metodă de test într-o instanță separată a clasei, ceea ce garantează izolarea între teste. Aceasta înseamnă că câmpurile clasei nu păstrează starea între diferitele metode @Test — fiecare test începe cu un obiect curat.

Structura de bază a unui test

Cel mai simplu test în JUnit arată ca o metodă cu adnotarea @Test, în interiorul căreia este apelat codul testat și rezultatul este verificat printr-o aserțiune. Dacă aserțiunea nu trece — testul este considerat eșuat, iar JUnit raportează eroarea.

@Test
void additionShouldReturnCorrectSum() {
    var calculator = new Calculator();
    var result = calculator.add(2, 3);
    assertEquals(5, result);
}

Test Runner găsește automat o astfel de metodă, o rulează și raportează rezultatul. Dacă metoda nu aruncă o excepție — testul este promovat (green). Dacă aserțiunea nu funcționează — testul eșuează (red).

Adnotări JUnit: ciclul de viață al testului

Adnotările JUnit determină când și cum trebuie executat codul de test. În JUnit 5, adnotările se află în pachetul org.junit.jupiter.api și acoperă toate etapele: pregătirea datelor, executarea testului, curățarea resurselor.

Exemplu de utilizare a adnotărilor

Să analizăm o clasă de test completă cu un ciclu de viață corect. Metoda setUp creează o instanță proaspătă de Calculator înainte de fiecare test, iar tearDown eliberează resursele — de exemplu, închide descriptori de fișiere sau conexiuni la baza de date.

class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void subtractionShouldReturnCorrectResult() {
        int result = calculator.subtract(10, 4);
        assertEquals(6, result);
    }

    @AfterEach
    void tearDown() {
        calculator.reset();
    }
}

Aserțiuni: verificarea rezultatelor în JUnit

Aserțiunile sunt metode statice care compară rezultatul real cu cel așteptat și aruncă o excepție în caz de nepotrivire. JUnit 5 oferă clasa org.junit.jupiter.api.Assertions cu peste 25 de metode pentru diferite scenarii de verificare — de la simpla comparație a valorilor până la verificarea timeout-urilor și a aserțiunilor de grup.

• assertEquals(expected, actual) — verifică egalitatea prin equals().
• assertTrue(condition) — verifică că condiția este adevărată.
• assertFalse(condition) — verifică că condiția este falsă.
• assertNotNull(object) — verifică că obiectul nu este null.
• assertNull(object) — verifică că obiectul este null.
• assertThrows(exception, executable) — verifică că codul aruncă excepția specificată.
• assertAll(executables) — grupează mai multe verificări și le execută pe toate, fără a se opri la prima eroare.

assertThrows pentru verificarea excepțiilor

Metoda assertThrows merită o atenție deosebită — permite verificarea faptului că codul gestionează corect situațiile eronate — împărțirea la zero, transmiterea null, depășirea limitelor.

@Test
void divisionByZeroShouldThrowException() {
    Calculator calc = new Calculator();

    ArithmeticException exception = assertThrows(
        ArithmeticException.class,
        () -> calc.divide(10, 0)
    );

    assertEquals("Cannot divide by zero", exception.getMessage());
}

Teste parametrizate în JUnit

Testele parametrizate permit rularea aceleiași metode de test cu diferite seturi de argumente. În JUnit 5, pentru aceasta se utilizează adnotarea @ParameterizedTest în combinație cu o sursă de date — @ValueSource, @CsvSource, @MethodSource sau @EnumSource.

Această abordare reduce radical duplicarea codului: în loc de zece teste identice pentru valori diferite, se scrie o singură metodă parametrizată. Conform Google Testing Blog, parametrizarea reduce volumul codului de test cu 40–60% fără pierderea acoperirii.

Exemplu cu CsvSource

Adnotarea @CsvSource transmite testului mai multe rânduri cu separatorul virgulă. Fiecare rând corespunde unei rulări a testului. JUnit convertește automat valorile șir în tipurile necesare: int, long, String și altele.

@ParameterizedTest
@CsvSource({
    "1,    1,   2",
    "2,    3,   5",
    "10,  20,  30",
    "-1,   1,   0"
})
void additionWithMultipleInputs(int a, int b, int expected) {
    assertEquals(expected, a + b);
}

MethodSource pentru obiecte complexe

Când datele de intrare sunt mai complexe decât numere simple sau șiruri, se utilizează @MethodSource. Acesta face referire la o metodă statică care returnează un Stream de argumente — de exemplu, Stream of Arguments sau Stream de obiecte User pentru testarea stratului DAO.

Integrarea JUnit cu proiectele Android

În dezvoltarea Android, JUnit este utilizat în pereche cu AndroidX Test, care oferă extensii pentru testarea Activity, Content Provider și a altor componente Android. JUnit se ocupă de testele unitare (unit tests) executate pe JVM fără emulator, iar AndroidX Test de testele instrumentale pe dispozitiv.

Configurarea Gradle

Pentru a conecta JUnit 5 într-un proiect Android, este suficient să adăugați dependența org.junit.jupiter:junit-jupiter în build.gradle la nivel de modul. Plugin-ul Gradle AGP suportă rularea testelor JUnit 5 pe JVM prin intermediul Test Runner-ului standard.

// build.gradle.kts
android {
    testOptions {
        unitTests.isIncludeAndroidResources = true
    }
}

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.11.0")
    testImplementation("androidx.test:core-ktx:1.6.1")
}

Testarea ViewModel cu JUnit

În practică, JUnit este cel mai frecvent utilizat pentru testarea ViewModel-urilor și a repository-urilor — straturi care nu necesită context Android sau emulator. Un astfel de test se execută în milisecunde și poate fi rulat de sute de ori fără pierdere de timp.

• ViewModel — verificarea stărilor: loading, success, error.
• Repository — verificarea mapării datelor și gestionarea erorilor.
• UseCase — verificarea logicii de afaceri cu mock-uri ale dependențelor.

JUnit 4 vs JUnit 5: diferențe cheie

JUnit 5 (Jupiter) nu este doar o versiune nouă, ci o platformă complet reproiectată, împărțită în trei module: JUnit Platform (rularea testelor pe JVM), JUnit Jupiter (API pentru scrierea testelor) și JUnit Vintage (compatibilitate inversă cu JUnit 4). O astfel de modularitate permite conectarea diferitelor motoare de test — de exemplu, Spek pentru Kotlin sau TestNG.

Migrarea de la JUnit 4 la JUnit 5 nu necesită rescrierea tuturor testelor — este suficient să conectați JUnit Vintage Engine, iar testele vechi vor continua să funcționeze. Testele noi se recomandă a fi scrise în JUnit 5 pentru a beneficia de extensii, lambdas în aserțiuni și suportul încorporat pentru parametrizare.