Testing i praksis: JUnit, Mockito og integrasjonstester · leksjon

Parametriserte og dynamiske tester

Skriv effektive tester som kjøres med flere datasett ved hjelp av parametriserte tester, og generer tester dynamisk under kjøring.

Leksjon 2 av 412 trinn

Parametriserte og dynamiske tester er en gratis leksjon i Testing i praksis: JUnit, Mockito og integrasjonstester på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Testing i praksis: JUnit, Mockito og integrasjonstester, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Testing i praksis: JUnit, Mockito og integrasjonstester inneholder totalt 4 leksjoner.

Introduksjon til datadrevet testing

Se for deg at du må teste en funksjon med mange ulike inndata. Det kan bli både tidkrevende og repetitivt å skrive en separat test for hver inndata.

Datadrevet testing lar deg kjøre den samme testlogikken flere ganger, men med ulike datasett for hver kjøring. Dette gjør testene mer effektive og enklere å vedlikeholde.

Hva er parametriserte tester?

Parameteriserte tester i JUnit 5 lar Dem skrive én testmetode som kan kjøres flere ganger med ulike argumenter. I stedet for å kopiere og lime inn testkode, oppgir De dataene, og JUnit håndterer iterasjonene.

Sparer tid og reduserer mengden standardkode.
Gir bedre testdekning ved at grenseverdier enkelt kan testes.
Gjør testene mer lesbare og enklere å vedlikeholde.

Bruke @ParameterizedTest

For å opprette en parameterisert test bruker De annotasjonen @ParameterizedTest i stedet for @Test. De må også oppgi en kilde for argumentene.

JUnit 5 tilbyr flere argumentkilder, for eksempel @ValueSource for enkeltargumenter eller @CsvSource for flere argumenter. La oss først se på @ValueSource.

Enkle data med @ValueSource

Annotasjonen @ValueSource egner seg perfekt til å oppgi enkle primitive datatyper direkte i testen. Den støtter strings, ints, longs, doubles og mer.

Hver verdi i kilden fører til at testmetoden kjøres én gang med denne verdien som argument.

@ValueSource i praksis

Her er et enkelt eksempel som tester om strenger ikke er null eller tomme. Legg merke til at testmetoden tar imot en String-parameter.

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

class StringValidatorTest {

    @ParameterizedTest
    @ValueSource(strings = {"apple", "banana", "orange"})
    void testStringsAreNotEmpty(String fruit) {
        Assertions.assertNotNull(fruit);
        Assertions.assertFalse(fruit.isEmpty());
    }
}

Flere argumenter med @CsvSource

Når testmetoden trenger mer enn ett argument, er @CsvSource nyttig. Den lar Dem definere argumenter som kommadelte verdier (CSV).

Hver streng i @CsvSource-matrisen representerer en rad med data, og verdiene deles opp ved komma for å samsvare med parameterne til testmetoden.

@CsvSource i praksis

La oss teste en enkel funksjon for addisjon. Hver linje i @CsvSource oppgir to tall og den forventede summen.

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class CalculatorTest {

    // Simple method to simulate
    int add(int a, int b) {
        return a + b;
    }

    @ParameterizedTest
    @CsvSource({"1, 1, 2", "2, 3, 5", "5, 0, 5"})
    void testAddMethod(int a, int b, int expectedSum) {
        Assertions.assertEquals(expectedSum, add(a, b));
    }
}

Generere dynamiske tester

Noen ganger er testdataene, eller til og med antallet tester, ikke kjent før programmet kjører. Det er her dynamiske tester virkelig kommer til sin rett!

I stedet for å definere alle testene ved kompilering lar dynamiske tester Dem generere dem programmatisk mens testene kjøres. Dette er nyttig i komplekse scenarier eller når dataene kommer fra eksterne kilder.

@TestFactory og DynamicTest

For å opprette dynamiske tester bruker De annotasjonen @TestFactory. En metode som er annotert med @TestFactory, kjører ikke en test selv, men produserer en samling av DynamicTest-instanser.

Metoder med @TestFactory må returnere en Stream, Collection, Iterable eller Iterator av DynamicTest.
Hver DynamicTest-instans har et visningsnavn og en kjørbar lambda.

Dynamisk test i praksis

Her er et eksempel som genererer tester for strenglengder. Hver test opprettes underveis basert på en liste med ord.

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;

import java.util.Arrays;
import java.util.Collection;

class DynamicTestExample {

    @TestFactory
    Collection<DynamicTest> dynamicTestsFromCollection() {
        return Arrays.asList(
            DynamicTest.dynamicTest("Test 'apple' length",
                () -> Assertions.assertEquals(5, "apple".length())),
            DynamicTest.dynamicTest("Test 'banana' length",
                () -> Assertions.assertEquals(6, "banana".length())),
            DynamicTest.dynamicTest("Test 'cat' length",
                () -> Assertions.assertEquals(3, "cat".length()))
        );
    }
}

Parameteriserte kontra dynamiske tester

Både parameteriserte og dynamiske tester bidrar til å redusere standardkode, men de dekker ulike behov.

Hva er den viktigste fordelen ved å bruke parameteriserte tester fremfor å skrive individuelle @Test-metoder for lignende testtilfeller?

Besvar den i den interaktive leksjonen

Oppsummering: Fleksibel testing

Godt jobbet! De har lært hvordan De kan gjøre JUnit-testene mer fleksible og effektive:

Parameteriserte tester (@ParameterizedTest med kilder som @ValueSource og @CsvSource) lar Dem kjøre den samme testlogikken med flere forhåndsdefinerte datasett.
Dynamiske tester (@TestFactory) lar Dem generere tester programmatisk under kjøring, noe som er ideelt når testtilfeller oppdages dynamisk.

Disse funksjonene hjelper Dem med å skrive renere og mer omfattende tester med mindre innsats!

Gratis å komme i gang

Lær deg Testing i praksis: JUnit, Mockito og integrasjonstester med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Parametriserte og dynamiske tester» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Testing i praksis: JUnit, Mockito og integrasjonstester, inkludert «Parametriserte og dynamiske tester», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Testing i praksis: JUnit, Mockito og integrasjonstester inneholder totalt 4 leksjoner.

Hva lærer jeg i «Parametriserte og dynamiske tester»?

Skriv effektive tester som kjøres med flere datasett ved hjelp av parametriserte tester, og generer tester dynamisk under kjøring. Du øver på Testing i praksis: JUnit, Mockito og integrasjonstester med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Testing i praksis: JUnit, Mockito og integrasjonstester?

Ingen tidligere erfaring er nødvendig. Testing i praksis: JUnit, Mockito og integrasjonstester på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Parametriserte og dynamiske tester»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Testing i praksis: JUnit, Mockito og integrasjonstester-leksjonen?

Ja. Alle Testing i praksis: JUnit, Mockito og integrasjonstester-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Testing i praksis: JUnit, Mockito og integrasjonstester