Testing Mastery: JUnit, Mockito & Integration Tests · Lektion

RESTful APIs testen

Verwenden Sie `MockMvc` oder `WebTestClient`, um umfassende Integrationstests für Ihre Spring-Boot-REST-Controller zu schreiben.

RESTful APIs testen ist eine kostenlose Testing Mastery: JUnit, Mockito & Integration Tests-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Testing Mastery: JUnit, Mockito & Integration Tests-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Testing Mastery: JUnit, Mockito & Integration Tests-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Why Test REST APIs?

RESTful APIs are the backbone of many modern applications. Testing them is crucial to ensure they work as expected, handle various inputs, and return correct responses.

This lesson focuses on how to write integration tests for your Spring Boot REST controllers using powerful tools: MockMvc and WebTestClient.

Spring Boot Test Setup

To test Spring Boot controllers, we need a special setup. The @SpringBootTest annotation loads the full application context, and @AutoConfigureMockMvc configures MockMvc for us.

Here's a basic structure for a controller test class:

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

Introducing MockMvc

MockMvc allows you to test your Spring MVC controllers without starting a full HTTP server. It simulates HTTP requests and responses, making tests fast and isolated.

It's ideal for testing the controller layer, ensuring routes, request mappings, and response formats are correct.

MockMvc: Testing GET Requests

Let's test a simple GET endpoint, for example, /api/hello which returns "Hello, CoddyKit!". We'll verify the HTTP status code and the response content.

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 with Path Variables

APIs often use path variables to identify resources, like /api/users/{id}. MockMvc handles these naturally.

Here's how to test an endpoint that takes an ID:

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: Testing POST Requests

For POST requests, you typically send a request body, often in JSON format. We can specify the content type and body using MockMvc.

Let's test an endpoint that creates an item:

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

Introducing WebTestClient

WebTestClient is a non-blocking, reactive client for testing web applications. It's part of Spring WebFlux but can also be used to test Spring MVC controllers.

It can perform actual HTTP calls (if configured to hit a running server).
It can also be backed by MockMvc for server-side testing similar to MockMvc itself, but with a reactive API.

WebTestClient in Action

Using WebTestClient is similar to MockMvc, but its fluent API often feels more modern, especially for reactive applications. Let's re-test our /api/hello endpoint.

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 vs. WebTestClient

When should you use MockMvc versus WebTestClient?

MockMvc: Best for traditional Spring MVC applications. It's server-side, simulates requests, and doesn't require a running server, making it fast.
WebTestClient: Ideal for reactive Spring WebFlux applications. It also provides a reactive client API for testing Spring MVC apps, offering a more modern, fluent way to write tests, and can even hit a live server for true end-to-end integration tests.

For most Spring Boot REST API integration tests focusing on the controller layer, MockMvc is a solid choice due to its speed and direct integration.

Quick Check: API Testing Tools

You are building a Spring Boot application using traditional Spring MVC. You want to write fast, isolated integration tests for your REST controllers without starting a full HTTP server.

Recap & Next Steps

In this lesson, you learned how to write comprehensive integration tests for your Spring Boot REST controllers. We covered:

Setting up your test environment with @SpringBootTest and @AutoConfigureMockMvc.
Using MockMvc to simulate GET and POST requests, verifying status and content.
Introducing WebTestClient for reactive testing and its alternative use cases.
Understanding the differences and when to choose between MockMvc and WebTestClient.

These tools are essential for building robust and reliable RESTful APIs!

Häufig gestellte Fragen

Ist die Lektion „RESTful APIs testen“ kostenlos?

Ja — der vollständige Text von „RESTful APIs testen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Testing Mastery: JUnit, Mockito & Integration Tests-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Testing Mastery: JUnit, Mockito & Integration Tests-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „RESTful APIs testen“?

Verwenden Sie `MockMvc` oder `WebTestClient`, um umfassende Integrationstests für Ihre Spring-Boot-REST-Controller zu schreiben. Du übst Testing Mastery: JUnit, Mockito & Integration Tests mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Testing Mastery: JUnit, Mockito & Integration Tests zu starten?

Keine Vorkenntnisse erforderlich. Testing Mastery: JUnit, Mockito & Integration Tests auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „RESTful APIs testen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Testing Mastery: JUnit, Mockito & Integration Tests-Lektion Code schreiben und ausführen?

Ja. Jede Testing Mastery: JUnit, Mockito & Integration Tests-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Spring-Test-Context-Framework
RESTful APIs testen
Eingebettete Datenbanken für Tests
Webschichten mit @WebMvcTest und MockMvc testen

← Zurück zu Testing Mastery: JUnit, Mockito & Integration Tests