Testen beheersen: JUnit, Mockito en integratietesten · Les

RESTful API's testen

Gebruik `MockMvc` of `WebTestClient` om uitgebreide integratietests voor uw Spring Boot REST-controllers te schrijven.

Les 2 van 411 stappen

RESTful API's testen is een gratis Testen beheersen: JUnit, Mockito en integratietesten-les op CoddyKit. Dit is les 2 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.

Waarom REST-API's testen?

RESTful API's vormen de ruggengraat van veel moderne toepassingen. Het is essentieel om ze te testen, zodat je zeker weet dat ze werken zoals verwacht, verschillende invoer verwerken en correcte antwoorden teruggeven.

Deze les richt zich op het schrijven van integratietests voor je Spring Boot REST-controllers met behulp van krachtige hulpmiddelen: MockMvc en WebTestClient.

Spring Boot-testinstellingen

Voor het testen van Spring Boot-controllers hebben we een speciale configuratie nodig. De annotatie @SpringBootTest laadt de volledige toepassingscontext en @AutoConfigureMockMvc configureert MockMvc voor ons.

Hier is een basisstructuur voor een testklasse van een controller:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest
@AutoConfigureMockMvc
public class MyApiControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void contextLoads() {
        // Your tests will go here
    }
}

Kennismaken met MockMvc

Met MockMvc kun je je Spring MVC-controllers testen zonder een volledige HTTP-server te starten. Het simuleert HTTP-verzoeken en -antwoorden, waardoor tests snel en geïsoleerd zijn.

Het is ideaal voor het testen van de controllerlaag, zodat je kunt controleren of routes, verzoektoewijzingen en antwoordindelingen correct zijn.

MockMvc: GET-verzoeken testen

Laten we een eenvoudig GET-eindpunt testen, bijvoorbeeld /api/hello, dat "Hello, CoddyKit!" retourneert. We controleren de HTTP-statuscode en de inhoud van het antwoord.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

// Assume a @RestController with @GetMapping("/api/hello") returning "Hello, CoddyKit!"
@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void testHelloEndpoint() throws Exception {
        mockMvc.perform(get("/api/hello"))
               .andExpect(status().isOk())
               .andExpect(content().string("Hello, CoddyKit!"));
    }
}

MockMvc: GET met padvariabelen

API's gebruiken vaak padvariabelen om bronnen te identificeren, zoals /api/users/{id}. MockMvc verwerkt deze op natuurlijke wijze.

Zo test je een eindpunt dat een ID accepteert:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

// Assume @GetMapping("/api/users/{id}") returns "User: " + id
@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void testGetUserById() throws Exception {
        mockMvc.perform(get("/api/users/{id}", 123))
               .andExpect(status().isOk())
               .andExpect(content().string("User: 123"));
    }
}

MockMvc: POST-verzoeken testen

Bij POST-verzoeken stuur je doorgaans een verzoektekst mee, vaak in JSON-indeling. Met MockMvc kunnen we het inhoudstype en de tekst opgeven.

Laten we een eindpunt testen dat een item maakt:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

// Assume @PostMapping("/api/items") creates an item and returns it
@SpringBootTest
@AutoConfigureMockMvc
public class ItemControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void testCreateItem() throws Exception {
        String newItemJson = "{\"name\":\"Laptop\", \"price\":1200}";
        mockMvc.perform(post("/api/items")
                       .contentType(MediaType.APPLICATION_JSON)
                       .content(newItemJson))
               .andExpect(status().isCreated())
               .andExpect(jsonPath("$.name").value("Laptop"));
    }
}

Kennismaken met WebTestClient

WebTestClient is een niet-blokkerende, reactieve client voor het testen van webtoepassingen. Het maakt deel uit van Spring WebFlux, maar kan ook worden gebruikt om Spring MVC-controllers te testen.

Het kan echte HTTP-aanroepen uitvoeren als het is geconfigureerd om een actieve server aan te spreken.
Het kan ook worden ondersteund door MockMvc voor tests aan de serverzijde, vergelijkbaar met MockMvc zelf, maar met een reactieve API.

WebTestClient in actie

WebTestClient gebruiken lijkt op het gebruik van MockMvc, maar de vloeiende API voelt vaak moderner aan, vooral voor reactieve toepassingen. Laten we ons eindpunt /api/hello opnieuw testen.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.web.reactive.server.WebTestClient;

// For WebTestClient with Spring MVC, we can use @SpringBootTest
// and inject WebTestClient.Builder to build it with MockMvc.webAppContextSetup
// For simplicity, this example assumes a WebFlux app or WebTestClient set up for MockMvc
// @SpringBootTest
// class HelloWebClientTest {
// @Autowired WebApplicationContext wac;
// WebTestClient client;
// @BeforeEach void setup() { client = WebTestClient.bindToApplicationContext(wac).build(); }
// ...

// For a simpler runnable example focusing on WebTestClient usage:
@WebFluxTest // This annotation sets up a minimal reactive context for WebTestClient
public class HelloWebClientTest {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    void testHelloEndpoint() {
        webTestClient.get().uri("/api/hello")
                     .exchange()
                     .expectStatus().isOk()
                     .expectBody(String.class).isEqualTo("Hello, CoddyKit!");
    }
}

MockMvc versus WebTestClient

Wanneer gebruik je MockMvc en wanneer WebTestClient?

MockMvc: het meest geschikt voor traditionele Spring MVC-toepassingen. Het werkt aan de serverzijde, simuleert verzoeken en vereist geen actieve server, waardoor het snel is.
WebTestClient: ideaal voor reactieve Spring WebFlux-toepassingen. Het biedt ook een reactieve client-API voor het testen van Spring MVC-toepassingen. Daarmee schrijf je tests op een modernere, vloeiende manier en kun je zelfs een actieve server aanspreken voor echte end-to-end-integratietests.

Voor de meeste Spring Boot-integratietests van REST-API's die zich op de controllerlaag richten, is MockMvc een solide keuze dankzij de snelheid en directe integratie.

Korte controle: hulpmiddelen voor API-tests

Je bouwt een Spring Boot-toepassing met traditionele Spring MVC. Je wilt snelle, geïsoleerde integratietests voor je REST-controllers schrijven zonder een volledige HTTP-server te starten.

Beantwoord dit in de interactieve les

Samenvatting en volgende stappen

In deze les heb je geleerd hoe je uitgebreide integratietests voor je Spring Boot REST-controllers schrijft. We hebben het volgende behandeld:

Je testomgeving instellen met @SpringBootTest en @AutoConfigureMockMvc.
MockMvc gebruiken om GET- en POST-verzoeken te simuleren en status en inhoud te controleren.
Kennismaken met WebTestClient voor reactief testen en de alternatieve gebruiksmogelijkheden ervan.
De verschillen begrijpen en bepalen wanneer je MockMvc of WebTestClient kiest.

Deze hulpmiddelen zijn essentieel voor het bouwen van robuuste en betrouwbare RESTful API's!

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 “RESTful API's testen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “RESTful API's testen”, 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 “RESTful API's testen”?

Gebruik `MockMvc` of `WebTestClient` om uitgebreide integratietests voor uw Spring Boot REST-controllers te schrijven. 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 2 van 4.

Hoe lang duurt de les “RESTful API's testen”?

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

Spring Test Context Framework
RESTful API's testen
Ingebouwde databases voor tests
Weblagen testen met @WebMvcTest en MockMvc

← Terug naar Testen beheersen: JUnit, Mockito en integratietesten