0Pricing
Spring Boot 4 Complete Guide · Lekcja

Testowanie integracyjne z Spring Boot

Proszę wykonywać testy integracyjne kontrolerów REST i repozytoriów danych, używając `@SpringBootTest`.

Testowanie integracyjne z Spring Boot to bezpłatna lekcja Spring Boot 4 Complete Guide na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Spring Boot 4 Complete Guide, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Spring Boot 4 Complete Guide zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

What is Integration Testing?

Welcome to integration testing with Spring Boot! So far, you've learned about unit testing, which isolates small pieces of code.

Integration tests, on the other hand, verify that different components of your application work correctly together. This often involves multiple layers, like your web controller, service, and even the database.

  • They test the 'glue' between components.
  • They catch issues that unit tests might miss.
  • They provide higher confidence in your application's behavior.

@SpringBootTest Annotation

The cornerstone of integration testing in Spring Boot is the @SpringBootTest annotation.

When you use @SpringBootTest, it loads the full Spring application context. This means all your beans (components), configurations, and properties are initialized, just like when your application starts normally.

It's powerful, but also heavier and slower than unit tests because it brings up more of your application.

A Simple Service Example

Let's imagine a simple greeting service that we want to test. This service will be part of our Spring Boot application.

Run this code to see the application context start, though it won't do much without an endpoint.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Service;

@SpringBootApplication
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }
}

@Service
class GreetingService {
  public String greet(String name) {
    return "Hello, " + name + "!";
  }
}

Testing a Service with @SpringBootTest

Here's how you'd write an integration test for our GreetingService. Notice we @Autowired the service directly.

When this test runs, @SpringBootTest ensures the GreetingService bean is available in the test context.

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class GreetingServiceIT {

  @Autowired
  private GreetingService greetingService;

  @Test
  void contextLoads() {
    assertThat(greetingService).isNotNull();
  }

  @Test
  void greetReturnsCorrectMessage() {
    String result = greetingService.greet("Coddy");
    assertThat(result).isEqualTo("Hello, Coddy!");
  }
}

Testing Web Layer with MockMvc

For testing REST controllers, we often don't want to start a full HTTP server. This is where MockMvc comes in.

MockMvc allows you to perform requests against your controllers in a simulated environment, without needing an actual running server. It's faster and more controlled.

  • Use @AutoConfigureMockMvc with @SpringBootTest.
  • Inject MockMvc to make requests.
  • Assert on status, content, and headers.

A Simple REST Controller

Let's add a simple REST controller to our application. This controller uses our GreetingService.

Run this code to start the application with the controller. You could access /api/greet?name=World in a browser if you had a full setup.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;

@SpringBootApplication
public class WebApp {
  public static void main(String[] args) {
    SpringApplication.run(WebApp.class, args);
  }
}

@RestController
class GreetingController {
  private final GreetingService greetingService;

  @Autowired
  public GreetingController(GreetingService service) {
    this.greetingService = service;
  }

  @GetMapping("/api/greet")
  public String greetUser(@RequestParam String name) {
    return greetingService.greet(name);
  }
}

@Service
class GreetingService {
  public String greet(String name) {
    return "Hello, " + name + "!";
  }
}

Testing GET Requests with MockMvc

Here's how to test our GreetingController's GET endpoint using MockMvc. We simulate an HTTP GET request to /api/greet with a query parameter.

We then assert that the HTTP status is OK (200) and the response content matches our expectation.

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;

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
class GreetingControllerIT {

  @Autowired
  private MockMvc mockMvc;

  @Test
  void greetUserEndpointReturnsCorrectMessage() throws Exception {
    mockMvc.perform(get("/api/greet?name=Coddy"))
           .andExpect(status().isOk())
           .andExpect(content().string("Hello, Coddy!"));
  }
}

Testing POST Requests

Testing POST requests with MockMvc is similar but involves specifying the HTTP method and potentially a request body. You often need to set the Content-Type header.

For example, if you had an endpoint to create a new user, you'd send a JSON payload in the request body.

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

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;

// Assuming a controller with @PostMapping("/api/users")
// and a method accepting @RequestBody User user

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIT {

  @Autowired
  private MockMvc mockMvc;

  @Test
  void createUserEndpointReturnsCreatedStatus() throws Exception {
    String newUserJson = "{\"name\":\"Jane Doe\", \"email\":\"jane@example.com\"}";

    mockMvc.perform(post("/api/users")
           .contentType(MediaType.APPLICATION_JSON)
           .content(newUserJson))
           .andExpect(status().isCreated()); // Expect HTTP 201 Created
  }
}

Testing Data Repositories

When testing your data layer (repositories), @SpringBootTest can also be used. You can @Autowired your repository interfaces directly.

It's common to use an in-memory database like H2 for these tests to ensure they are fast and don't affect your development database. Also, @Transactional can ensure tests clean up after themselves.

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

// Example Entity (e.g., in src/main/java/com/coddykit/User.java)
// public class User { private Long id; private String name; /* getters/setters */ }

// Example Repository (e.g., in src/main/java/com/coddykit/UserRepository.java)
interface User {
  Long getId();
  void setId(Long id);
  String getName();
  void setName(String name);
}

@Repository
interface UserRepository extends CrudRepository<User, Long> {
  User findByName(String name);
}

@SpringBootTest
@Transactional // Each test runs in a transaction and rolls back
class UserRepositoryIT {

  @Autowired
  private UserRepository userRepository;

  @Test
  void findByNameReturnsUser() {
    // Create and save a user for the test
    // (In a real scenario, User would be a JPA @Entity)
    User user = new User() {
      private Long id;
      private String name;
      public Long getId() { return id; }
      public void setId(Long id) { this.id = id; }
      public String getName() { return name; }
      public void setName(String name) { this.name = name; }
    };
    user.setName("TestUser");
    userRepository.save(user);

    User foundUser = userRepository.findByName("TestUser");
    assertThat(foundUser).isNotNull();
    assertThat(foundUser.getName()).isEqualTo("TestUser");
  }
}

Quick Check on @SpringBootTest

You've learned how @SpringBootTest helps with integration tests. Let's see if you can recall its primary function.

Recap: Integration Testing

Great job! You've explored the world of integration testing in Spring Boot.

  • @SpringBootTest loads the entire application context for comprehensive tests.
  • MockMvc allows you to simulate HTTP requests against your controllers without a running server, making web layer tests faster and more reliable.
  • You can test service and repository layers by autowiring them directly into @SpringBootTest classes, often with an in-memory database.

Integration tests are crucial for verifying that all parts of your Spring Boot application work harmoniously.

Często zadawane pytania

Czy lekcja „Testowanie integracyjne z Spring Boot” jest bezpłatna?

Tak — pełny tekst „Testowanie integracyjne z Spring Boot” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Spring Boot 4 Complete Guide, przejdź na CoddyKit PRO. Kurs Spring Boot 4 Complete Guide zawiera 4 lekcji w sumie.

Co nauczysz się w „Testowanie integracyjne z Spring Boot”?

Proszę wykonywać testy integracyjne kontrolerów REST i repozytoriów danych, używając `@SpringBootTest`. Ćwiczysz Spring Boot 4 Complete Guide z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Spring Boot 4 Complete Guide?

Nie wymagamy żadnego doświadczenia. Spring Boot 4 Complete Guide w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Testowanie integracyjne z Spring Boot”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Spring Boot 4 Complete Guide?

Tak. Każda lekcja Spring Boot 4 Complete Guide zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Testy jednostkowe z JUnit i Mockito
  2. Testowanie integracyjne z Spring Boot
  3. Testowanie wycinków i TestContainers
  4. Testowanie kontrolerów Web za pomocą MockMvc
← Powrót do Spring Boot 4 Complete Guide