Testning på avancerad nivå: JUnit, Mockito och integrationstester · Lektion

Testning av undantag och tidsgränser

Verifiera förväntade undantag och implementera tidsgränser för att förhindra oändliga loopar eller långvariga testfall.

Lektion 3 av 411 steg

Testning av undantag och tidsgränser är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Testning på avancerad nivå: JUnit, Mockito och integrationstester, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Testa förväntade fel

Ibland är koden utformad för att kasta ett fel under vissa ogiltiga förhållanden, till exempel vid division med noll. Undantagstestning säkerställer att koden hanterar sådana situationer korrekt.

Validerar både lyckade och misslyckade körvägar.
Bekräftar att felmeddelandena är korrekta.

Fånga undantag med JUnit

JUnit 5 tillhandahåller metoden assertThrows för att verifiera att ett specifikt undantag kastas. Det är det rekommenderade och renaste sättet att testa förväntade undantag.

Den tar emot den förväntade undantagstypen, till exempel IllegalArgumentException.class.
Den tar emot ett lambda-uttryck, alltså en liten kodbit, som ska utlösa undantaget.

`assertThrows` i praktiken

Vi tittar på assertThrows i ett enkelt test. Metoden divide i vår Calculator ska kasta ett IllegalArgumentException om divisorn är noll.

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

Kontrollera undantagsdetaljer

Det räcker ofta inte att bara veta *att* ett undantag kastades. Du kan också vilja verifiera detaljerna, till exempel undantagsmeddelandet eller andra egenskaper.

Metoden assertThrows returnerar själva undantagsobjektet, vilket gör att du kan utföra ytterligare assertioner på det.

Verifiera undantagsmeddelandet

Här sparar vi undantagsobjektet som returneras av assertThrows och använder sedan assertEquals för att verifiera meddelandet. Det gör dina undantagstester mycket precisa.

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

Förhindra oändliga tester med tidsgränser

Ibland kan en koddel fastna i en oändlig loop eller ta oväntat lång tid att slutföra. Det kan göra att testsviten hänger sig på obestämd tid.

Tidsgränser är en viktig funktion som automatiskt underkänner ett test om det överskrider en angiven tidslängd, så att testsviten körs effektivt.

Ställa in tidsgränser med `@Timeout`

JUnit 5 använder annoteringen @Timeout för att ange en maximal tidslängd för testmetoder eller hela testklasser. Du anger det maximala value och en tidsenhet i unit.

Vanliga enheter är TimeUnit.SECONDS, TimeUnit.MILLISECONDS och TimeUnit.MINUTES.
Om testet körs längre än den angivna tiden underkänns det.

Exempel på tidsgräns på metodnivå

Så här tillämpar du en tidsgräns på en enskild testmetod. Om longRunningTask() tar mer än 1 sekund underkänns testet automatiskt.

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

Tidsgränser på klassnivå

Du kan också använda annoteringen @Timeout på klassnivå. När den placeras på en testklass ärver alla testmetoder i klassen den angivna tidsgränsen.

Om en testmetod också har en egen annotering med @Timeout åsidosätter tidsgränsen på metodnivå den på klassnivå för just den metoden.

Testa dina kunskaper

Vilken JUnit 5-funktion passar bäst för att säkerställa att en testmetod slutförs inom en fördefinierad tidsgräns och underkänns om gränsen överskrids?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Undantag och tidsgränser

I den här lektionen har du lärt dig att skriva robusta tester för förväntade fel och förhindra tester som aldrig avslutas:

Du använde assertThrows för att verifiera att specifika undantag kastas av koden.
Du lärde dig att verifiera specifika detaljer i ett undantag, till exempel dess meddelande.
Du använde annoteringen @Timeout för att ange tidsgränser för testmetoder och testklasser, vilket säkerställer effektiv testkörning.

Gratis att börja

Lär dig Testning på avancerad nivå: JUnit, Mockito och integrationstester med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Testning av undantag och tidsgränser” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Testning av undantag och tidsgränser”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Vad lär jag mig i ”Testning av undantag och tidsgränser”?

Verifiera förväntade undantag och implementera tidsgränser för att förhindra oändliga loopar eller långvariga testfall. Ni övar på Testning på avancerad nivå: JUnit, Mockito och integrationstester med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Testning på avancerad nivå: JUnit, Mockito och integrationstester?

Du behöver inga förkunskaper. Utbildningen i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Testning av undantag och tidsgränser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektionen?

Ja. Varje Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Testning på avancerad nivå: JUnit, Mockito och integrationstester