Groovy og Gradle: JVM-automatisering og byggeutvikling · leksjon

Enhets- og integrasjonstesting

Konfigurer Gradle til å kjøre JUnit-, TestNG- eller Spock-tester, og håndter testavhengigheter.

Leksjon 1 av 412 trinn

Enhets- og integrasjonstesting er en gratis leksjon i Groovy og Gradle: JVM-automatisering og byggeutvikling på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Groovy og Gradle: JVM-automatisering og byggeutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Groovy og Gradle: JVM-automatisering og byggeutvikling inneholder totalt 4 leksjoner.

Hvorfor teste? Gradles rolle

Automatisert testing er avgjørende for programvarekvaliteten. Det bidrar til å finne feil tidlig og sikrer at koden fungerer som forventet etter endringer.

Gradle har utmerket innebygd støtte for å kjøre ulike typer tester, noe som gjør det enkelt å integrere testing i byggeprosessen.

Enhetstester: Kontrollerer små, isolerte deler av koden.
Integrasjonstester: Kontrollerer hvordan ulike deler av systemet fungerer sammen.

Gradles standardoppsett for testing

Når De bruker java-pluginen i Gradle, konfigurerer den automatisk en test-oppgave for Dem. Denne oppgaven finner og kjører enhetstestene Deres.

Som standard ser Gradle etter testklasser i src/test/java (eller src/test/groovy) og forventer at de følger standard navnekonvensjoner, for eksempel at navnet slutter med Test.

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}
// The 'java' plugin automatically creates a 'test' task.
// No explicit 'test' task definition needed here.

Integrering av JUnit 5

For å skrive tester trenger De et testrammeverk. JUnit 5 er et populært valg for Java og Groovy. De deklarerer det som en testImplementation-avhengighet i build.gradle-filen.

testImplementation betyr at avhengigheten bare er tilgjengelig når tester kompileres og kjøres, og ikke for hovedprogrammets kode.

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
}

Deres første enhetstest

La oss opprette en enkel Calculator-klasse. Vi legger til en main-metode i denne klassen slik at den kan kjøres for demonstrasjonsformål. Enhetstestene skal deretter kontrollere metodene uavhengig av hverandre.

package com.coddykit;

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("2 + 3 = " + calc.add(2, 3));
    }
}

Skrive enhetstesten

La oss nå skrive en JUnit 5-test for Calculator. Denne testen kontrollerer at add-metoden fungerer riktig. Gradles test-oppgave finner og kjører denne testen.

package com.coddykit;

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

public class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3), "2 + 3 should be 5");
    }
}

Kjøre tester med Gradle

For å kjøre enhetstestene Deres utfører De ganske enkelt test-oppgaven fra prosjektets rotmappe på kommandolinjen. Gradle kompilerer testene, kjører dem og rapporterer resultatene.

En vellykket kjøring betyr at alle testene besto! Hvis en test mislykkes, viser Gradle detaljene.

// In your terminal, navigate to the project root and run:
// gradle test
//
// Expected output will include details about test execution.
// Example excerpt:
// > Task :test
// com.coddykit.CalculatorTest > testAdd() PASSED
//
// BUILD SUCCESSFUL in ...

Gjennomgå testresultater

Etter at testene er kjørt, genererer Gradle detaljerte rapporter. Som standard finner De disse rapportene i mappen build/reports/tests/test.

Der finner De en HTML-rapport (index.html) som gir en brukervennlig oversikt over alle testkjøringer, inkludert tester som besto, mislyktes eller ble hoppet over.

HTML-rapport: Visuell oppsummering av alle tester.
XML-rapport: Maskinlesbart format for CI/CD-verktøy.

// Locate your test reports here:
// build/reports/tests/test/index.html

Hva er integrasjonstester?

Mens enhetstester kontrollerer isolerte komponenter, verifiserer integrasjonstester at ulike deler av programmet fungerer riktig når de kombineres.

De innebærer ofte samhandling med databaser, API-er eller andre eksterne tjenester. Derfor er de tregere, men avgjørende for systemets generelle helsetilstand.

Enhetstester: Raske og isolerte; tester én enkelt enhet.
Integrasjonstester: Tregere; involverer flere komponenter og tester samhandling.

Separat kildekodesett for integrasjonstester

Det er god praksis å skille integrasjonstester fra enhetstester. Da kan De kjøre dem uavhengig av hverandre. Dette kan De gjøre ved å definere et nytt source set i build.gradle.

Dette kildekodesettet får sin egen kompilering og kjøretids-classpath, adskilt fra hovedkoden og enhetstestkoden.

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

sourceSets {
    integrationTest {
        java {
            srcDirs = ['src/integrationTest/java']
        }
        resources {
            srcDirs = ['src/integrationTest/resources']
        }
        compileClasspath += main.output + test.output
        runtimeClasspath += main.output + test.output
    }
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'

    integrationTestImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    integrationTestRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
    // Add other integration-specific dependencies here
}

Egendefinert oppgave for integrasjonstester

Når De har et separat kildekodesett, trenger De en egendefinert Gradle-oppgave for å kjøre integrasjonstestene. Denne oppgaven skal være av typen Test og konfigureres til å bruke integrationTest-kildekodesettet.

Deretter kan De kjøre oppgaven fra kommandolinjen: gradle integrationTest. Det er vanlig å la check-oppgaven avhenge av integrationTest, slik at gradle check kjører både enhets- og integrasjonstester.

// build.gradle (continued from previous scene)
task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    shouldRunAfter test // Ensures unit tests run first
}

check.dependsOn integrationTest // Make 'check' task also run integration tests

Hurtigsjekk: Testtyper

Vurder følgende scenarioer:

Testing av én enkelt metode i en hjelpeklasse uten eksterne avhengigheter.
Testing av om programmet kan koble seg til en database og hente data.

Hvilket scenario beskriver best en enhetstest, og hvilket beskriver en integrasjonstest?

Besvar den i den interaktive leksjonen

Oppsummering: Enhets- og integrasjonstesting

Godt jobbet! De har lært hvordan De konfigurerer og kjører tester med Gradle.

Gradles java-plugin tilbyr en standard test-oppgave.
Vi la til JUnit 5-avhengigheter ved hjelp av testImplementation.
Vi skrev og kjørte grunnleggende enhetstester med gradle test.
Vi forsto forskjellen mellom enhets- og integrasjonstester.
Vi konfigurerte et separat kildekodesett og en egendefinert oppgave for integrasjonstester.

Deretter skal vi utforske hvordan detaljerte testrapporter genereres og tolkes!

Gratis å komme i gang

Lær deg Groovy 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 «Enhets- og integrasjonstesting» gratis?

Ja – hele teksten i «Enhets- og integrasjonstesting» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Groovy og Gradle: JVM-automatisering og byggeutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Groovy og Gradle: JVM-automatisering og byggeutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Enhets- og integrasjonstesting»?

Konfigurer Gradle til å kjøre JUnit-, TestNG- eller Spock-tester, og håndter testavhengigheter. Du øver på Groovy og Gradle: JVM-automatisering og byggeutvikling 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 Groovy og Gradle: JVM-automatisering og byggeutvikling?

Ingen tidligere erfaring er nødvendig. Groovy og Gradle: JVM-automatisering og byggeutvikling 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 1 av 4.

Hvor lang tid tar leksjonen «Enhets- og integrasjonstesting»?

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 Groovy og Gradle: JVM-automatisering og byggeutvikling-leksjonen?

Ja. Alle Groovy og Gradle: JVM-automatisering og byggeutvikling-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 Groovy og Gradle: JVM-automatisering og byggeutvikling