Testen beheersen: JUnit, Mockito en integratietesten · Les

Exceptiontests en time-outs

Controleer verwachte exceptions en implementeer time-outs om oneindige lussen of langlopende testgevallen te voorkomen.

Les 3 van 411 stappen

Exceptiontests en time-outs is een gratis Testen beheersen: JUnit, Mockito en integratietesten-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Testen beheersen: JUnit, Mockito en integratietesten. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Testen beheersen: JUnit, Mockito en integratietesten bevat in totaal 4 lessen.

Testen op verwachte fouten

Soms is je code ontworpen om onder specifieke, ongeldige omstandigheden een fout te veroorzaken, bijvoorbeeld bij een deling door nul. Met testen van uitzonderingen controleer je of je code deze situaties correct afhandelt.

Je valideert zowel het pad voor succes als dat voor fouten.
Je controleert of je foutmeldingen juist zijn.

Uitzonderingen opvangen met JUnit

JUnit 5 biedt de methode assertThrows om te controleren of een specifieke uitzondering wordt veroorzaakt. Dit is de aanbevolen en duidelijkste manier om op verwachte uitzonderingen te testen.

De methode accepteert het verwachte type uitzondering, bijvoorbeeld IllegalArgumentException.class.
De methode accepteert een lambda-expressie (een klein stukje code) die de uitzondering moet veroorzaken.

`assertThrows` in actie

Laten we assertThrows in een eenvoudige test bekijken. Onze Calculator-methode divide moet een IllegalArgumentException veroorzaken als de deler nul is.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class Calculator {
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Divisor cannot be zero");
        }
        return a / b;
    }
}

public class ExceptionTest {
    @Test
    void testDivideByZeroThrowsException() {
        Calculator calc = new Calculator();
        assertThrows(IllegalArgumentException.class, () -> {
            calc.divide(10, 0);
        });
    }
}

Details van uitzonderingen controleren

Vaak is het niet genoeg om alleen te weten dat er een uitzondering is veroorzaakt. Misschien wil je ook de details controleren, zoals de uitzonderingsmelding of andere eigenschappen.

De methode assertThrows retourneert het werkelijke uitzonderingsobject, zodat je er aanvullende beweringen op kunt uitvoeren.

Uitzonderingsmelding controleren

Hier slaan we het uitzonderingsobject op dat door assertThrows wordt geretourneerd en gebruiken we vervolgens assertEquals om de melding te controleren. Zo worden je tests voor uitzonderingen zeer nauwkeurig.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class Calculator {
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Divisor cannot be zero");
        }
        return a / b;
    }
}

public class ExceptionMessageTest {
    @Test
    void testDivideByZeroMessage() {
        Calculator calc = new Calculator();
        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class,
            () -> calc.divide(10, 0),
            "Expected divide() to throw, but it didn't"
        );
        assertEquals("Divisor cannot be zero", thrown.getMessage());
    }
}

Eindeloze tests voorkomen met time-outs

Soms kan een stuk code vastlopen in een oneindige lus of onverwacht lang duren. Hierdoor kan je testsuite onbeperkt blijven hangen.

Time-outs zijn een belangrijke functie die een test automatisch laat mislukken als deze langer duurt dan een opgegeven tijdsduur. Zo blijft je testsuite efficiënt werken.

Time-outs instellen met `@Timeout`

JUnit 5 gebruikt de annotatie @Timeout om een maximale duur in te stellen voor testmethoden of volledige testklassen. Je geeft de maximale value en een tijdseenheid, oftewel unit, op.

Veelgebruikte eenheden zijn TimeUnit.SECONDS, TimeUnit.MILLISECONDS en TimeUnit.MINUTES.
Als de test langer duurt dan de opgegeven tijd, mislukt deze.

Voorbeeld van een time-out op methodeniveau

Zo pas je een time-out toe op één testmethode. Als longRunningTask() langer dan 1 seconde duurt, mislukt deze test automatisch.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;

public class TimeoutMethodTest {

    // A method that might take too long
    private void longRunningTask() throws InterruptedException {
        Thread.sleep(1500); // Simulates a task taking 1.5 seconds
    }

    @Test
    @Timeout(value = 1, unit = TimeUnit.SECONDS)
    void testTaskShouldCompleteWithinOneSecond() throws InterruptedException {
        longRunningTask(); // This will cause the test to fail due to timeout
        assertTrue(true, "Task completed (but it will timeout)");
    }
}

Time-outs op klasseniveau

Je kunt de annotatie @Timeout ook op klasseniveau toepassen. Wanneer je deze op een testklasse plaatst, nemen alle testmethoden binnen die klasse de opgegeven time-out over.

Als een testmethode ook een eigen annotatie @Timeout heeft, overschrijft de time-out op methodeniveau die op klasseniveau voor die specifieke methode.

Test je kennis

Welke functie van JUnit 5 is het meest geschikt om ervoor te zorgen dat een testmethode binnen een vooraf bepaalde tijd wordt uitgevoerd en mislukt als die tijd wordt overschreden?

Beantwoord dit in de interactieve les

Samenvatting: uitzonderingen en time-outs

In deze les heb je geleerd robuuste tests te schrijven voor verwachte fouten en te voorkomen dat tests blijven doorlopen:

Je hebt assertThrows gebruikt om te controleren of je code specifieke uitzonderingen veroorzaakt.
Je hebt geleerd specifieke details van een uitzondering te controleren, zoals de melding.
Je hebt de annotatie @Timeout toegepast om tijdslimieten in te stellen voor je testmethoden en -klassen, zodat tests efficiënt worden uitgevoerd.

Gratis beginnen

Leer Testen beheersen: JUnit, Mockito en integratietesten met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Exceptiontests en time-outs” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “Exceptiontests en time-outs”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Testen beheersen: JUnit, Mockito en integratietesten bevat in totaal 4 lessen.

Wat leer ik in “Exceptiontests en time-outs”?

Controleer verwachte exceptions en implementeer time-outs om oneindige lussen of langlopende testgevallen te voorkomen. Je oefent met Testen beheersen: JUnit, Mockito en integratietesten door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Testen beheersen: JUnit, Mockito en integratietesten te beginnen?

Ervaring vooraf is niet nodig. Testen beheersen: JUnit, Mockito en integratietesten op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Exceptiontests en time-outs”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Testen beheersen: JUnit, Mockito en integratietesten?

Ja. Elke les over Testen beheersen: JUnit, Mockito en integratietesten bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Testen beheersen: JUnit, Mockito en integratietesten