JUnit: wat is het, kernconcepten en hoe het werkt

Wat is JUnit?

JUnit is een open-source framework voor het schrijven en uitvoeren van herhaalbare unittesten in Java en Kotlin. Het maakt deel uit van het xUnit-ecosysteem — een familie van frameworks gebaseerd op de architectuur van Kent Beck en Erich Gamma — en is het standaard testinstrument in Android Studio en IntelliJ IDEA.

De belangrijkste taak van JUnit is het isoleren van een klein stukje code (methode, klasse) en het controleren van het gedrag onder gecontroleerde omstandigheden. Tests worden geschreven als gewone Java/Kotlin-klassen met annotaties, en het framework zorgt voor het detecteren van tests, het beheren van hun levenscyclus en het verzamelen van uitvoeringsstatistieken.

De eerste versie van JUnit verscheen in 1997 en veranderde de ontwikkelingsaanpak radicaal door de Test-Driven Development (TDD) praktijken te populariseren. Tegenwoordig is JUnit 5 (Jupiter) de huidige versie, volledig herontworpen met een modulaire architectuur en ondersteuning voor Java 8+ en extensies.

Hoe werkt JUnit

Het mechanisme van JUnit-uitvoering is gebaseerd op het Test Runner-patroon, dat de classpath scant, methoden met de @Test-annotatie vindt, een instantie van de testklasse maakt en de methoden in een bepaalde volgorde uitvoert. De Test Runner beheert de levenscyclus: aanroep BeforeAll → BeforeEach → Test → AfterEach → AfterAll.

Levenscyclus van de testklasse

JUnit omhult elke testmethode in een afzonderlijke klassinstantie, wat isolatie tussen tests garandeert. Dit betekent dat de velden van de klasse geen toestand behouden tussen verschillende @Test-methoden — elke test begint met een schoon object.

Basisstructuur van een test

De eenvoudigste test in JUnit ziet eruit als een methode met de @Test-annotatie, waarin de te testen code wordt aangeroepen en het resultaat wordt gecontroleerd via een assertie. Als de assertie faalt — wordt de test als mislukt beschouwd en rapporteert JUnit de fout.

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

De Test Runner vindt automatisch zo’n methode, voert deze uit en rapporteert het resultaat. Als de methode geen uitzondering gooit — is de test geslaagd (green). Als de assertie niet werkt — faalt de test (red).

JUnit annotaties: levenscyclus van de test

Annotaties van JUnit bepalen wanneer en hoe de testcode moet worden uitgevoerd. In JUnit 5 bevinden de annotaties zich in het pakket org.junit.jupiter.api en bestrijken ze alle fasen: gegevensvoorbereiding, testuitvoering, opschonen van bronnen.

Voorbeeld van het gebruik van annotaties

Laten we een volledige testklasse met een correcte levenscyclus bekijken. De methode setUp maakt een nieuwe instantie van Calculator voor elke test, en tearDown maakt bronnen vrij — bijvoorbeeld het sluiten van bestandsdescriptors of databaseverbindingen.

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

Asserties: resultaten controleren in JUnit

Asserties zijn statische methoden die het werkelijke resultaat vergelijken met het verwachte en een uitzondering gooien bij een mismatch. JUnit 5 biedt de klasse org.junit.jupiter.api.Assertions met meer dan 25 methoden voor verschillende controlescenario’s — van eenvoudige waardevergelijking tot controle van timeouts en groepsasserties.

• assertEquals(expected, actual) — controleert gelijkheid via equals().
• assertTrue(condition) — controleert of de voorwaarde waar is.
• assertFalse(condition) — controleert of de voorwaarde onwaar is.
• assertNotNull(object) — controleert of het object niet null is.
• assertNull(object) — controleert of het object null is.
• assertThrows(exception, executable) — controleert of de code de opgegeven uitzondering gooit.
• assertAll(executables) — groepeert meerdere controles en voert ze allemaal uit zonder te stoppen bij de eerste fout.

assertThrows voor het controleren van uitzonderingen

De methode assertThrows verdient speciale aandacht — deze maakt het mogelijk om te controleren of de code foutsituaties correct afhandelt — delen door nul, null doorgeven, overschrijden van limieten.

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

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

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

Geparametriseerde tests in JUnit

Geparametriseerde tests maken het mogelijk dezelfde testmethode met verschillende argumentensets uit te voeren. In JUnit 5 wordt hiervoor de annotatie @ParameterizedTest gebruikt in combinatie met een gegevensbron — @ValueSource, @CsvSource, @MethodSource of @EnumSource.

Deze aanpak vermindert het dupliceren van code drastisch: in plaats van tien identieke tests voor verschillende waarden wordt één geparametriseerde methode geschreven. Volgens de Google Testing Blog vermindert parametrisering de hoeveelheid testcode met 40–60% zonder verlies van dekking.

Voorbeeld met CsvSource

De annotatie @CsvSource geeft meerdere regels met een komma als scheidingsteken door aan de test. Elke regel komt overeen met één uitvoering van de test. JUnit converteert de tekenreekswaarden automatisch naar de vereiste typen: int, long, String en andere.

@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 voor complexe objecten

Wanneer de invoergegevens complexer zijn dan eenvoudige getallen of tekenreeksen, wordt @MethodSource gebruikt. Het verwijst naar een statische methode die een Stream van argumenten retourneert — bijvoorbeeld Stream of Arguments of een Stream van User-objecten voor het testen van de DAO-laag.

Integratie van JUnit met Android-projecten

In Android-ontwikkeling wordt JUnit gebruikt in combinatie met AndroidX Test, dat extensies biedt voor het testen van Activity, Content Provider en andere Android-componenten. JUnit is verantwoordelijk voor unittesten (unit tests) die op de JVM worden uitgevoerd zonder emulator, en AndroidX Test voor instrumentele tests op het apparaat.

Gradle-configuratie

Om JUnit 5 in een Android-project aan te sluiten, volstaat het om de afhankelijkheid org.junit.jupiter:junit-jupiter toe te voegen in build.gradle op moduleniveau. De AGP Gradle-plugin ondersteunt het uitvoeren van JUnit 5-tests op de JVM via de standaard Test Runner.

// 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 testen met JUnit

In de praktijk wordt JUnit het meest gebruikt voor het testen van ViewModel-klassen en repositories — lagen die geen Android-context of emulator nodig hebben. Zo’n test wordt in milliseconden uitgevoerd en kan honderden keren worden gedraaid zonder tijdverlies.

• ViewModel — controleren van statussen: loading, success, error.
• Repository — controleren van gegevensmapping en foutafhandeling.
• UseCase — controleren van bedrijfslogica met mocks van afhankelijkheden.

JUnit 4 vs JUnit 5: belangrijkste verschillen

JUnit 5 (Jupiter) is niet zomaar een nieuwe versie, maar een volledig herontworpen platform verdeeld over drie modules: JUnit Platform (uitvoeren van tests op de JVM), JUnit Jupiter (API voor het schrijven van tests) en JUnit Vintage (achterwaartse compatibiliteit met JUnit 4). Deze modulariteit maakt het mogelijk verschillende Test Engines aan te sluiten — bijvoorbeeld Spek voor Kotlin of TestNG.

Migratie van JUnit 4 naar JUnit 5 vereist niet dat alle tests worden herschreven — het volstaat om JUnit Vintage Engine aan te sluiten en oude tests blijven werken. Nieuwe tests worden aanbevolen in JUnit 5 te schrijven om gebruik te maken van extensies, lambdas in asserties en ingebouwde ondersteuning voor parametrisering.