JUnit: vad det är, nyckelbegrepp och hur det fungerar

Vad är JUnit?

JUnit — är ett ramverk med öppen källkod för att skriva och köra repeterbara enhetstester i Java och Kotlin. Det ingår i xUnit-ekosystemet — en familj av ramverk baserade på Kent Beck och Erich Gammas arkitektur — och är det standardiserade testverktyget i Android Studio och IntelliJ IDEA.

JUnits huvuduppgift är att isolera en liten kodbit (metod, klass) och kontrollera dess beteende under kontrollerade förhållanden. Tester skrivs som vanliga Java/Kotlin-klasser med annoteringar, och ramverket hanterar testupptäckt, livscykelhantering och insamling av exekveringsstatistik.

Den första versionen av JUnit kom 1997 och förändrade radikalt utvecklingsmetodiken genom att popularisera Test-Driven Development (TDD). Idag är JUnit 5 (Jupiter) den aktuella versionen, helt omarbetad med en modulär arkitektur som stöder Java 8+ och tillägg.

Hur JUnit fungerar

Mekanismen för JUnit-exekvering bygger på Test Runner-mönstret, som skannar classpath, hittar metoder med @Test-annoteringen, skapar en instans av testklassen och kör metoderna i en viss ordning. Test Runner hanterar livscykeln: BeforeAll → BeforeEach → Test → AfterEach → AfterAll.

Testklassens livscykel

JUnit omsluter varje testmetod i en separat klassinstans, vilket garanterar isolering mellan tester. Detta innebär att klassens fält inte bevarar tillstånd mellan olika @Test-metoder — varje test börjar med ett rent objekt.

Testets grundstruktur

Det enklaste JUnit-testet ser ut som en metod med @Test-annoteringen, där den testade koden anropas och resultatet kontrolleras via en assertion. Om assertionen misslyckas anses testet ha misslyckats och JUnit rapporterar ett fel.

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

Test Runner hittar automatiskt en sådan metod, kör den och rapporterar resultatet. Om metoden inte kastar något undantag — testet är godkänt (grönt). Om assertionen misslyckas — testet fallerar (rött).

JUnit-annoteringar: testets livscykel

JUnit-annoteringar bestämmer när och hur testkoden ska exekveras. I JUnit 5 finns annoteringarna i paketet org.junit.jupiter.api och täcker alla faser: dataförberedelse, testexekvering, resursrensning.

Exempel på annoteringsanvändning

Låt oss titta på en komplett testklass med korrekt livscykel. Metoden setUp skapar en ny Calculator-instans före varje test, och tearDown frigör resurser — till exempel stänger filhandtag eller databasanslutningar.

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

Assertions: kontrollera resultat i JUnit

Assertions — är statiska metoder som jämför det faktiska resultatet med det förväntade och kastar ett undantag vid avvikelse. JUnit 5 erbjuder klassen org.junit.jupiter.api.Assertions med över 25 metoder för olika kontrollscenarier — från enkel värdejämförelse till timeout-kontroll och gruppassertioner.

• assertEquals(expected, actual) — kontrollerar likhet via equals().
• assertTrue(condition) — kontrollerar att villkoret är sant.
• assertFalse(condition) — kontrollerar att villkoret är falskt.
• assertNotNull(object) — kontrollerar att objektet inte är null.
• assertNull(object) — kontrollerar att objektet är null.
• assertThrows(exception, executable) — kontrollerar att koden kastar det angivna undantaget.
• assertAll(executables) — grupperar flera kontroller och kör alla utan att stanna vid första felet.

assertThrows för undantagskontroll

Särskild uppmärksamhet förtjänar metoden assertThrows, som gör det möjligt att kontrollera att koden korrekt hanterar felsituationer — division med noll, null-överföring, gränsöverskridning.

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

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

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

Parametriserade tester i JUnit

Parametriserade tester gör det möjligt att köra samma testmetod med olika uppsättningar argument. I JUnit 5 används annoteringen @ParameterizedTest i kombination med en datakälla — @ValueSource, @CsvSource, @MethodSource eller @EnumSource.

Detta tillvägagångssätt minskar kodduplicering radikalt: istället för tio identiska tester för olika värden skrivs en parametriserad metod. Enligt Google Testing Blog minskar parametrisering testkodens volym med 40–60% utan att täckningen minskar.

Exempel med CsvSource

Annoteringen @CsvSource skickar flera rader med kommaavgränsad data till testet. Varje rad motsvarar en testkörning. JUnit konverterar automatiskt strängvärden till önskade typer: int, long, String med flera.

@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 för komplexa objekt

När indata är mer komplexa än enkla tal eller strängar används @MethodSource. Den refererar till en statisk metod som returnerar en ström av argument — till exempel en ström av Arguments eller en ström av User-objekt för testning av DAO-lagret.

Integration av JUnit med Android-projekt

I Android-utveckling används JUnit tillsammans med AndroidX Test, som tillhandahåller tillägg för testning av Activity, Content Provider och andra Android-komponenter. JUnit ansvarar för enhetstester (unit tests) som körs på JVM utan emulator, medan AndroidX Test ansvarar för instrumenterade tester på enheten.

Gradle-konfiguration

För att lägga till JUnit 5 i ett Android-projekt räcker det att lägga till beroendet org.junit.jupiter:junit-jupiter i build.gradle på modulnivå. AGP Gradle-plugin stöder körning av JUnit 5-tester på JVM via standard 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")
}

Testa ViewModel med JUnit

I praktiken används JUnit oftast för att testa ViewModel och datalager — lager som inte kräver Android-kontext eller emulator. Sådana tester körs på millisekunder och kan köras hundratals gånger utan tidsförlust.

• ViewModel — kontroll av tillstånd: loading, success, error.
• Repository — kontroll av datamappning och felhantering.
• UseCase — kontroll av affärslogik med mockade beroenden.

JUnit 4 vs JUnit 5: viktiga skillnader

JUnit 5 (Jupiter) är inte bara en ny version, utan en helt omarbetad plattform uppdelad i tre moduler: JUnit Platform (körning av tester på JVM), JUnit Jupiter (API för att skriva tester) och JUnit Vintage (bakåtkompatibilitet med JUnit 4). Denna modularitet gör det möjligt att ansluta olika Test Engine — till exempel Spek för Kotlin eller TestNG.

Migration från JUnit 4 till JUnit 5 kräver inte omskrivning av alla tester — det räcker med att lägga till JUnit Vintage Engine, och gamla tester fortsätter att fungera. Nya tester rekommenderas att skrivas med JUnit 5 för att använda tillägg, lambda-uttryck i assertions och inbyggt stöd för parametrisering.