JUnit: mi ez, kulcsfogalmak és hogyan működik

Mi az a JUnit?

A JUnit egy nyílt forráskódú keretrendszer ismételhető egységtesztek írásához és futtatásához Java és Kotlin nyelven. Része a xUnit ökoszisztémának — a Kent Beck és Erich Gamma által megalkotott architektúrán alapuló keretrendszerek családjának — és ez a szabványos tesztelőeszköz az Android Studio-ban és az IntelliJ IDEA-ban.

A JUnit fő feladata egy kis kódrészlet (metódus, osztály) elkülönítése és viselkedésének ellenőrzése ellenőrzött körülmények között. A tesztek szokásos Java/Kotlin osztályokként íródnak annotációkkal, a keretrendszer pedig gondoskodik a tesztek felismeréséről, életciklusuk kezeléséről és a végrehajtási statisztikák gyűjtéséről.

A JUnit első változata 1997-ben jelent meg és gyökeresen megváltoztatta a fejlesztési szemléletet, népszerűsítve a Tesztvezérelt fejlesztés (TDD) gyakorlatait. Ma a JUnit 5 (Jupiter) a jelenlegi változat, teljesen útervezve moduláris architektúrával, Java 8+ és bővítmények támogatásával.

Hogyan működik a JUnit

A JUnit végrehajtásának mechanizmusa a Test Runner mintán alapul, amely beolvassa a classpath-t, megtalálja a @Test annotációval ellátott metódusokat, létrehozza a tesztosztály példányát és meghatározott sorrendben futtatja a metódusokat. A Test Runner kezeli az életciklust: BeforeAll → BeforeEach → Test → AfterEach → AfterAll hívás.

A tesztosztály életciklusa

A JUnit minden tesztmetódust külön osztálypéldányba csomagol, ami elkülönítést garantál a tesztek között. Ez azt jelenti, hogy az osztály mezői nem őrzik meg az állapotot a különböző @Test metódusok között — minden teszt tiszta objektummal kezdődik.

A teszt alapstruktúrája

A legegyszerűbb teszt a JUnit-ban egy @Test annotációval ellátott metódusként néz ki, amelyben a tesztelt kód meghívásra kerül, és az eredmény egy assertion segítségével kerül ellenőrzésre. Ha az assertion nem megy át — a teszt sikertelennek tekintendő, és a JUnit hibát jelent.

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

A Test Runner automatikusan megtalálja az ilyen metódust, futtatja és jelenti az eredményt. Ha a metólus nem dob kivételt — a teszt sikeres (green). Ha az assertion nem működik — a teszt megbukik (red).

JUnit annotációk: a teszt életciklusa

A JUnit annotációi meghatározzák, hogy a tesztkód mikor és hogyan kerüljön végrehajtásra. A JUnit 5-ben az annotációk a org.junit.jupiter.api csomagban találhatók és lefedik az összes fázist: adatok előkészítése, teszt végrehajtása, erőforrások felszabadítása.

Példa az annotációk használatára

Nézzünk meg egy teljes tesztosztályt helyes életciklussal. A setUp metódus minden teszt előtt létrehoz egy friss Calculator példányt, a tearDown pedig felszabadítja az erőforrásokat — például bezárja a fájlleírókat vagy az adatbázis-kapcsolatokat.

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();
    }
}

Assertion-ök: eredmények ellenőrzése a JUnit-ban

Az Assertion-ök statikus metódusok, amelyek összehasonlítják a tényleges eredményt a várttal, és kivételt dobnak, ha nem egyeznek. A JUnit 5 a org.junit.jupiter.api.Assertions osztályt kínálja több mint 25 metódussal különböző ellenőrzési forgatókönyvekhez — az egyszerű értékösszehasonlítástól az időtúllépések és csoportos assertion-ök ellenőrzéséig.

• assertEquals(expected, actual) — ellenőrzi az egyenlőséget equals()-en keresztül.
• assertTrue(condition) — ellenőrzi, hogy a feltétel igaz.
• assertFalse(condition) — ellenőrzi, hogy a feltétel hamis.
• assertNotNull(object) — ellenőrzi, hogy az objektum nem null.
• assertNull(object) — ellenőrzi, hogy az objektum null.
• assertThrows(exception, executable) — ellenőrzi, hogy a kód a megadott kivételt dobja.
• assertAll(executables) — csoportosít több ellenőrzést és mindet végrehajtja anélkül, hogy az első hibánál megállna.

assertThrows kivételek ellenőrzéséhez

Az assertThrows metódus külön figyelmet érdemel — lehetővé teszi annak ellenőrzését, hogy a kód helyesen kezeli a hibás helyzeteket — nullával osztás, null átadása, határértékek túllépése.

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

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

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

Paraméterezett tesztek a JUnit-ban

A paraméterezett tesztek lehetővé teszik ugyanazon tesztmetódus futtatását különböző argumentumkészletekkel. A JUnit 5-ben erre a @ParameterizedTest annotáció szolgál egy adatforrással kombinálva — @ValueSource, @CsvSource, @MethodSource vagy @EnumSource.

Ez a megközelítés drasztikusan csökkenti a kódismétlést: tíz azonos teszt helyett különböző értékekre egy paraméterezett metódust írunk. A Google Testing Blog szerint a paraméterezés 40–60%-kal csökkenti a tesztkód mennyiségét a lefedettség elvesztése nélkül.

Példa CsvSource-szal

A @CsvSource annotáció több sort küld a tesztnek vesszővel elválasztva. Minden sor egy tesztfuttatásnak felel meg. A JUnit automatikusan konvertálja a sztring értékeket a szükséges típusokra: int, long, String és mások.

@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 összetett objektumokhoz

Amikor a bemeneti adatok összetettebbek, mint az egyszerű számok vagy sztringek, a @MethodSource-t használjuk. Ez egy statikus metódusra hivatkozik, amely argumentumok Stream-jét adja vissza — például Arguments Stream vagy User objektumok Stream-je a DAO réteg teszteléséhez.

JUnit integrációja Android-projektekkel

Az Android-fejlesztésben a JUnit-ot az AndroidX Test-tel együtt használják, amely bővítményeket biztosít az Activity, Content Provider és más Android komponensek teszteléséhez. A JUnit felel az egységteszteért (unit tests), amelyek a JVM-en futnak emulátor nélkül, az AndroidX Test pedig az eszközön futó instrumentális tesztekért.

Gradle beállítás

A JUnit 5 Android-projektbe történő csatlakoztatásához elég a org.junit.jupiter:junit-jupiter függőség hozzáadása a modul szintű build.gradle-ben. Az AGP Gradle plug-in támogatja a JUnit 5 tesztek futtatását a JVM-en a szabványos Test Runneren keresztül.

// 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")
}

ViewModel tesztelése JUnit-tal

A gyakorlatban a JUnit-ot leggyakrabban a ViewModel és tárolók tesztelésére használják — azon rétegekért, amelyek nem igényelnek Android kontextust vagy emulátort. Egy ilyen teszt ezredmásodpercek alatt végrehajtható és százszor is lefuttatható időveszteség nélkül.

• ViewModel — állapotok ellenőrzése: loading, success, error.
• Repository — adatleképezés és hibakezelés ellenőrzése.
• UseCase — üzleti logika ellenőrzése függőségek mock-jaival.

JUnit 4 vs JUnit 5: főbb különbségek

A JUnit 5 (Jupiter) nem csupán új változat, hanem teljesen útervezett platform, három modulra bontva: JUnit Platform (tesztek futtatása a JVM-en), JUnit Jupiter (API tesztek írásához) és JUnit Vintage (visszafelé kompatibilitás a JUnit 4-gyel). Ez a modularitás lehetővé teszi különböző Test Engine-ek csatlakoztatását — például Spek a Kotlinhoz vagy TestNG.

A JUnit 4-ről JUnit 5-re történő migráció nem igényli az összes teszt újraírását — elég csatlakoztatni a JUnit Vintage Engine-t, és a régi tesztek továbbra is működni fognak. Az új teszteket érdemes JUnit 5-ben írni, hogy kihasználhassuk a bővítményeket, a lambda kifejezéseket az assertion-ökben és a beépített paraméterezési támogatást.