Testning på avancerad nivå: JUnit, Mockito och integrationstester · Lektion

Testa REST-API:er

Använd `MockMvc` eller `WebTestClient` för att skriva heltäckande integrationstester för era Spring Boot REST-controllers.

Lektion 2 av 411 steg

Testa REST-API:er är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Testning på avancerad nivå: JUnit, Mockito och integrationstester, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Varför testa REST-API:er?

RESTful API:er utgör ryggraden i många moderna applikationer. Det är viktigt att testa dem för att säkerställa att de fungerar som förväntat, hanterar olika indata och returnerar korrekta svar.

Den här lektionen fokuserar på hur du skriver integrationstester för Spring Boot REST-controllers med hjälp av kraftfulla verktyg: MockMvc och WebTestClient.

Konfigurera Spring Boot-test

För att testa Spring Boot-controllers behöver vi en särskild konfiguration. Annoteringen @SpringBootTest läser in hela applikationskontexten, och @AutoConfigureMockMvc konfigurerar MockMvc åt oss.

Här är en grundläggande struktur för en testklass för en 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
    }
}

Introduktion till MockMvc

MockMvc låter dig testa dina Spring MVC-controllers utan att starta en fullständig HTTP-server. Det simulerar HTTP-anrop och svar, vilket gör testerna snabba och isolerade.

Det passar utmärkt för att testa controllerlagret och säkerställa att routes, request-mappningar och svarsformat är korrekta.

MockMvc: testa GET-anrop

Vi testar en enkel GET-endpoint, till exempel /api/hello, som returnerar "Hello, CoddyKit!". Vi verifierar HTTP-statuskoden och innehållet i svaret.

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 med sökvägsvariabler

API:er använder ofta sökvägsvariabler för att identifiera resurser, till exempel /api/users/{id}. MockMvc hanterar detta naturligt.

Så här testar du en endpoint som tar emot ett 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: testa POST-anrop

Vid POST-anrop skickar du vanligtvis en request body, ofta i JSON-format. Med MockMvc kan vi ange innehållstyp och body.

Vi testar en endpoint som skapar ett objekt:

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

Introduktion till WebTestClient

WebTestClient är en icke-blockerande, reaktiv klient för testning av webbapplikationer. Den ingår i Spring WebFlux men kan även användas för att testa Spring MVC-controllers.

Den kan utföra faktiska HTTP-anrop om den konfigureras för att anropa en körande server.
Den kan även använda MockMvc som grund för testning på serversidan, ungefär som MockMvc självt, men med ett reaktivt API.

WebTestClient i praktiken

Att använda WebTestClient liknar att använda MockMvc, men dess fluent API känns ofta modernare, särskilt för reaktiva applikationer. Vi testar vår endpoint /api/hello igen.

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 jämfört med WebTestClient

När bör du använda MockMvc respektive WebTestClient?

MockMvc: Bäst för traditionella Spring MVC-applikationer. Det används på serversidan, simulerar anrop och kräver ingen körande server, vilket gör det snabbt.
WebTestClient: Idealisk för reaktiva Spring WebFlux-applikationer. Den tillhandahåller även ett reaktivt klient-API för testning av Spring MVC-appar, vilket ger ett modernare och mer fluent sätt att skriva tester. Den kan dessutom anropa en aktiv server för verkliga end-to-end-integrationstester.

För de flesta integrationstester av Spring Boot REST API:er som fokuserar på controllerlagret är MockMvc ett bra val tack vare sin snabbhet och direkta integration.

Snabb kontroll: verktyg för API-testning

Du bygger en Spring Boot-applikation med traditionell Spring MVC. Du vill skriva snabba, isolerade integrationstester för dina REST-controllers utan att starta en fullständig HTTP-server.

Besvara frågan i den interaktiva lektionen

Sammanfattning och nästa steg

I den här lektionen har du lärt dig att skriva omfattande integrationstester för dina Spring Boot REST-controllers. Vi gick igenom:

Hur testmiljön konfigureras med @SpringBootTest och @AutoConfigureMockMvc.
Hur MockMvc används för att simulera GET- och POST-anrop samt verifiera status och innehåll.
En introduktion till WebTestClient för reaktiv testning och alternativa användningsområden.
Skillnaderna mellan MockMvc och WebTestClient samt när du bör välja det ena framför det andra.

De här verktygen är viktiga för att bygga robusta och tillförlitliga RESTful API:er!

Gratis att börja

Lär dig Testning på avancerad nivå: JUnit, Mockito och integrationstester med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Testa REST-API:er” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Testa REST-API:er”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Vad lär jag mig i ”Testa REST-API:er”?

Använd `MockMvc` eller `WebTestClient` för att skriva heltäckande integrationstester för era Spring Boot REST-controllers. Ni övar på Testning på avancerad nivå: JUnit, Mockito och integrationstester med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Testning på avancerad nivå: JUnit, Mockito och integrationstester?

Du behöver inga förkunskaper. Utbildningen i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Testa REST-API:er”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektionen?

Ja. Varje Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Spring Test Context Framework
Testa REST-API:er
Inbäddade databaser för tester
Testa webblager med @WebMvcTest och MockMvc

← Tillbaka till Testning på avancerad nivå: JUnit, Mockito och integrationstester