Groovy en Gradle: JVM-automatisering en buildbeheer · Les

Unit- en integratietests

Configureer Gradle voor het uitvoeren van JUnit-, TestNG- of Spock-tests en beheer testdependencies.

Les 1 van 412 stappen

Unit- en integratietests is een gratis Groovy en Gradle: JVM-automatisering en buildbeheer-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Groovy en Gradle: JVM-automatisering en buildbeheer. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Groovy en Gradle: JVM-automatisering en buildbeheer bevat in totaal 4 lessen.

Waarom testen? De rol van Gradle

Geautomatiseerd testen is essentieel voor de kwaliteit van software. Het helpt bugs vroeg te vinden en zorgt ervoor dat je code na wijzigingen werkt zoals verwacht.

Gradle biedt uitstekende ingebouwde ondersteuning voor het uitvoeren van verschillende soorten tests, waardoor je testen eenvoudig in je buildproces kunt integreren.

Unittests: Controleren kleine, geïsoleerde delen van je code.
Integratietests: Controleren hoe verschillende delen van je systeem samenwerken.

De standaardtestconfiguratie van Gradle

Wanneer je de java-plugin toepast in Gradle, configureert deze automatisch een test-taak voor je. Deze taak zoekt je unittests en voert ze uit.

Standaard zoekt Gradle naar testklassen in src/test/java (of src/test/groovy) en verwacht het dat ze de gebruikelijke naamgevingsconventies volgen, zoals eindigen op Test.

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

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

JUnit 5 integreren

Om tests te schrijven heb je een testframework nodig. JUnit 5 is een populaire keuze voor Java en Groovy. Je declareert het als een testImplementation-afhankelijkheid in je build.gradle-bestand.

testImplementation betekent dat de afhankelijkheid alleen beschikbaar is tijdens het compileren en uitvoeren van tests, niet voor de code van je hoofdapplicatie.

// 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'
}

Je eerste unittest

We maken een eenvoudige klasse Calculator. We voegen een main-methode toe aan deze klasse, zodat we haar ter demonstratie kunnen uitvoeren. Unittests controleren daarna de methoden afzonderlijk.

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

Je unittest schrijven

We schrijven nu een JUnit 5-test voor onze Calculator. Deze test controleert of de add-methode correct werkt. Gradles test-taak vindt deze test en voert hem uit.

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

Tests uitvoeren met Gradle

Om je unittests uit te voeren, voer je de test-taak uit vanuit de hoofdmap van je project op de opdrachtregel. Gradle compileert je tests, voert ze uit en rapporteert de resultaten.

Een geslaagde uitvoering betekent dat alle tests zijn geslaagd! Als een test mislukt, toont Gradle je de details.

// 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 ...

Testresultaten bekijken

Na het uitvoeren van tests genereert Gradle gedetailleerde rapporten. Standaard vind je deze rapporten in de map build/reports/tests/test.

Daar vind je een HTML-rapport (index.html) met een overzichtelijke samenvatting van alle testruns, inclusief geslaagde, mislukte en overgeslagen tests.

HTML-rapport: Visueel overzicht van alle tests.
XML-rapport: Door machines leesbaar formaat voor CI/CD-tools.

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

Wat zijn integratietests?

Waar unittests geïsoleerde componenten controleren, verifiëren integratietests of verschillende delen van je applicatie correct werken wanneer ze worden gecombineerd.

Ze omvatten vaak interactie met databases, API's of andere externe services. Daardoor zijn ze trager, maar wel essentieel voor de algehele gezondheid van het systeem.

Unittests: Snel, geïsoleerd en gericht op afzonderlijke eenheden.
Integratietests: Trager, omvatten meerdere componenten en testen interacties.

Een afzonderlijke bronset voor integratietests

Het is een goede gewoonte om integratietests van unittests te scheiden. Zo kun je ze onafhankelijk uitvoeren. Dit doe je door een nieuwe bronset te definiëren in je build.gradle.

Deze bronset heeft een eigen compilatie- en runtime-classpath, los van je hoofdcode en testcode voor unittests.

// 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
}

Aangepaste taak voor integratietests

Zodra je een afzonderlijke bronset hebt, heb je een aangepaste Gradle-taak nodig om je integratietests uit te voeren. Deze taak is van het type Test en wordt geconfigureerd om je integrationTest-bronset te gebruiken.

Je kunt deze taak vervolgens uitvoeren vanaf de opdrachtregel: gradle integrationTest. Het is gebruikelijk om de check-taak afhankelijk te maken van integrationTest, zodat gradle check zowel unit- als integratietests uitvoert.

// 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

Snelle controle: testtypen

Bekijk de volgende scenario's:

Een enkele methode van een hulpprogrammaklasse testen zonder externe afhankelijkheden.
Testen of je applicatie succesvol verbinding kan maken met een database en gegevens kan ophalen.

Welk scenario beschrijft het best een unittest en welk scenario een integratietest?

Beantwoord dit in de interactieve les

Samenvatting: unit- en integratietests

Goed gedaan! Je hebt geleerd hoe je tests met Gradle instelt en uitvoert.

Gradles java-plugin biedt een standaardtaak test.
We hebben JUnit 5-afhankelijkheden toegevoegd met testImplementation.
We hebben eenvoudige unittests geschreven en uitgevoerd met gradle test.
We hebben het verschil tussen unit- en integratietests leren begrijpen.
We hebben een afzonderlijke bronset en aangepaste taak voor integratietests geconfigureerd.

Vervolgens bekijken we hoe je gedetailleerde testrapporten genereert en interpreteert!

Gratis beginnen

Leer Groovy 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 “Unit- en integratietests” gratis?

Ja — de volledige tekst van “Unit- en integratietests” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Groovy en Gradle: JVM-automatisering en buildbeheer wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Groovy en Gradle: JVM-automatisering en buildbeheer bevat in totaal 4 lessen.

Wat leer ik in “Unit- en integratietests”?

Configureer Gradle voor het uitvoeren van JUnit-, TestNG- of Spock-tests en beheer testdependencies. Je oefent met Groovy en Gradle: JVM-automatisering en buildbeheer 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 Groovy en Gradle: JVM-automatisering en buildbeheer te beginnen?

Ervaring vooraf is niet nodig. Groovy en Gradle: JVM-automatisering en buildbeheer 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 1 van 4.

Hoe lang duurt de les “Unit- en integratietests”?

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 Groovy en Gradle: JVM-automatisering en buildbeheer?

Ja. Elke les over Groovy en Gradle: JVM-automatisering en buildbeheer 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 Groovy en Gradle: JVM-automatisering en buildbeheer