Testy integracyjne w Spring Boot 4 – Testcontainers i WireMock

Testowanie jest jednym z kluczowych elementów tworzenia niezawodnych aplikacji. W ekosystemie Spring Boot mamy do dyspozycji wiele narzędzi, które pozwalają weryfikować poprawność działania aplikacji na różnych poziomach.

Testy jednostkowe koncentrują się na pojedynczych klasach lub metodach, zazwyczaj z wykorzystaniem mocków zastępujących ich zależności. Pozwalają szybko sprawdzić poprawność logiki biznesowej, ale nie gwarantują, że poszczególne komponenty będą prawidłowo ze sobą współpracować.

Testy integracyjne idą o krok dalej. Ich zadaniem jest weryfikacja współpracy kilku komponentów aplikacji, np. kontrolera, serwisu, repozytorium i bazy danych.

W przypadku aplikacji Spring Boot szczególnie przydatne są następujące narzędzia:

  • JUnit 5 – framework służący do definiowania i uruchamiania testów (znasz go z testów jednostkowych).
  • Spring Boot Test – umożliwia uruchomienie kontekstu Spring i testowanie współpracy komponentów aplikacji.
  • Testcontainers – pozwala uruchamiać rzeczywiste zależności, takie jak PostgreSQL, w kontenerach Docker.
  • WireMock – umożliwia symulowanie zewnętrznych usług REST API.
  • MockMvc – pozwala testować endpointy HTTP bez konieczności uruchamiania rzeczywistego serwera.

W tym artykule zbuduję prostą aplikację Spring Boot 4, która pobiera dane z PostgreSQL oraz komunikuje się z zewnętrznym REST API. Następnie przygotuję testy integracyjne wykorzystujące wymienione narzędzia, aby sprawdzić poprawność działania całego procesu – od żądania HTTP aż po odpowiedź zwracaną klientowi.

Przygotowanie aplikacji Spring Boot do testowania

Na potrzeby artykułu przygotowana zostanie prosta aplikacja Spring Boot, której zadaniem będzie pobieranie podsumowania zamówień klienta.

Aplikacja będzie korzystać z dwóch źródeł danych:

  • PostgreSQL – przechowującego informacje o zamówieniach.
  • Zewnętrznego REST API – udostępniającego dane klientów.

Endpoint GET /api/customers/{id}/summary zwróci imię i nazwisko klienta, liczbę opłaconych zamówień oraz ich łączną wartość.

Przykładowa odpowiedź:

{
  "customerName": "John Smith",
  "paidOrders": 3,
  "totalAmount": 450.00
}

Konfiguracja w Maven

Przykład oparty jest na Java 21 i Spring Boot 4.1.2.

Na początek potrzebne są następujące zależności:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-restclient</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Zależności związane z testowaniem zostaną dodane w kolejnych rozdziałach.

Encja Order

Baza danych będzie zawierała jedną tabelę o nazwie orders, przechowującą identyfikator klienta, status zamówienia oraz jego wartość.

@Entity
@Table(name = "orders")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long customerId;

    @Enumerated(EnumType.STRING)
    private Status status;

    private BigDecimal totalAmount;

    protected Order() {}

    public Order(Long customerId, Status status,
                 BigDecimal totalAmount) {
        this.customerId = customerId;
        this.status = status;
        this.totalAmount = totalAmount;
    }

    public enum Status {
        PAID, CANCELLED
    }
}

Dla uproszczenia model ograniczony został do pól niezbędnych w przykładzie. Encja nie wymaga dodatkowych relacji ani rozbudowanej logiki biznesowej.

OrderRepository

Repozytorium będzie odpowiadało za agregowanie zamówień konkretnego klienta.

public interface OrderRepository
        extends JpaRepository<Order, Long> {

    interface c{
        Long getPaidOrders();
        BigDecimal getTotalAmount();
    }

    @Query("""
        SELECT COUNT(o) AS paidOrders,
               SUM(o.totalAmount) AS totalAmount
        FROM Order o
        WHERE o.customerId = :customerId
          AND o.status = :status
        GROUP BY o.customerId
        HAVING COUNT(o) >= :minOrders
        """)
    Optional<OrderStats> findStats(
        @Param("customerId") Long customerId,
        @Param("status") Order.Status status,
        @Param("minOrders") long minOrders
    );
}

Zapytanie wykorzystuje kilka mechanizmów JPQL:

  • COUNT – zlicza zamówienia.
  • SUM – oblicza ich łączną wartość.
  • GROUP BY – grupuje zamówienia według klienta.
  • HAVING – ogranicza wynik do klientów posiadających odpowiednią liczbę zamówień.

Wynik mapowany jest na projekcję interfejsową OrderStats, dzięki czemu nie ma potrzeby pobierania pełnych encji.

Zapytanie stanowi również dobry przypadek do testowania z wykorzystaniem rzeczywistej bazy PostgreSQL.

CustomerClient – komunikacja z zewnętrznym API

Informacje o kliencie będą pobierane z zewnętrznego serwisu za pomocą RestClient.

@Component
public class CustomerClient {

    private final RestClient restClient;

    public CustomerClient(
            RestClient.Builder builder,
            @Value("${customer.api.base-url}") String url) {

        this.restClient = builder.baseUrl(url).build();
    }

    public CustomerData getCustomer(Long id) {
        return restClient.get()
            .uri("/customers/{id}", id)
            .retrieve()
            .body(CustomerData.class);
    }

    public record CustomerData(String name) {}
}

Podczas testowania rzeczywisty serwis zostanie zastąpiony przez WireMock, który będzie zwracał przygotowane wcześniej odpowiedzi HTTP.

CustomerService – logika biznesowa

Serwis łączy dane pochodzące z repozytorium oraz zewnętrznego API.

@Service
public class CustomerService {

    private final OrderRepository repository;
    private final CustomerClient customerClient;

    public CustomerService(
            OrderRepository repository,
            CustomerClient customerClient) {
        this.repository = repository;
        this.customerClient = customerClient;
    }

    public Summary getSummary(Long customerId) {
        var stats = repository.findStats(
                customerId, Order.Status.PAID, 2)
            .orElseThrow(() ->
                new ResponseStatusException(
                    HttpStatus.NOT_FOUND));

        var customer = customerClient
            .getCustomer(customerId);

        return new Summary(
            customer.name(),
            stats.getPaidOrders(),
            stats.getTotalAmount()
        );
    }

    public record Summary(
        String customerName,
        Long paidOrders,
        BigDecimal totalAmount
    ) {}
}

Serwis zwraca podsumowanie wyłącznie wtedy, gdy klient posiada co najmniej dwa opłacone zamówienia. W przeciwnym przypadku zgłaszany jest wyjątek ResponseStatusException, skutkujący odpowiedzią HTTP 404.

CustomerController

Ostatnim elementem aplikacji jest prosty kontroler REST:

@RestController
@RequestMapping("/api/customers")
public class CustomerController {

    private final CustomerService service;

    public CustomerController(CustomerService service) {
        this.service = service;
    }

    @GetMapping("/{id}/summary")
    public CustomerService.Summary getSummary(
            @PathVariable Long id) {
        return service.getSummary(id);
    }
}

Kontroler udostępnia jeden endpoint i deleguje obsługę żądania do warstwy serwisowej.

W ten sposób powstała niewielka aplikacja, której działanie zależy zarówno od bazy PostgreSQL, jak i zewnętrznego REST API. Taka architektura pozwala pokazać zastosowanie Testcontainers, WireMock i MockMvc w jednym spójnym teście integracyjnym.

Konfiguracja application.yml

Konfiguracja aplikacji obejmuje połączenie z bazą PostgreSQL, ustawienia Hibernate oraz adres zewnętrznego REST API.

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/ordersdb
    username: postgres
    password: postgres

  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

customer:
  api:
    base-url: http://localhost:8089

Właściwość ddl-auto: create-drop powoduje automatyczne utworzenie schematu bazy podczas uruchamiania aplikacji i jego usunięcie przy zamykaniu. Takie ustawienie jest wygodne na potrzeby przykładu, ale nie powinno być stosowane w środowisku produkcyjnym.

Podczas testów integracyjnych połączenie z lokalnym PostgreSQL zostanie zastąpione połączeniem z kontenerem Testcontainers za pomocą adnotacji @ServiceConnection. Z kolei adres zewnętrznego API zostanie przekierowany na serwer WireMock.

Testcontainers – konfiguracja w testach integracyjnych

Testcontainers to biblioteka Java umożliwiająca uruchamianie rzeczywistych zależności aplikacji, takich jak bazy danych, brokerzy wiadomości czy systemy cache, w kontenerach Docker.

W przypadku testów integracyjnych pozwala zastąpić lokalną bazę PostgreSQL tymczasową instancją uruchamianą automatycznie na potrzeby testów.

Takie podejście ma kilka zalet:

  • Testy wykonywane są na rzeczywistym silniku bazy danych, a nie jego zamienniku, np. H2.
  • Nie ma potrzeby ręcznego przygotowywania bazy danych.
  • Środowisko testowe jest powtarzalne i niezależne od lokalnej instalacji PostgreSQL.
  • Po zakończeniu testów kontener jest automatycznie usuwany.

Do korzystania z Testcontainers wymagane jest działające środowisko kontenerowe, np. Docker.

Zależności Maven

Do pliku pom.xml należy dodać następujące zależności:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-testcontainers</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers-junit-jupiter</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers-postgresql</artifactId>
    <scope>test</scope>
</dependency>

Spring Boot zarządza wersjami powyższych bibliotek, dlatego przy korzystaniu z jego mechanizmu dependency management nie trzeba podawać ich ręcznie.

Pierwszy test integracyjny – uruchomienie kontekstu Spring Boot

Najprostszym testem integracyjnym jest sprawdzenie, czy aplikacja Spring Boot uruchamia się poprawnie.

Do tego celu wystarczy adnotacja @SpringBootTest oraz pusta metoda testowa:

@SpringBootTest
@Testcontainers
class CustomerIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer postgres =
        new PostgreSQLContainer("postgres:17-alpine");

    @Test
    void contextLoads() {
    }
}

Mimo że metoda contextLoads() nie zawiera żadnej instrukcji, test wykonuje szereg operacji:

  • Uruchamia kontener PostgreSQL za pomocą Testcontainers.
  • Inicjalizuje kontekst Spring Boot.
  • Tworzy i konfiguruje beany aplikacji.
  • Nawiązuje połączenie z bazą danych.
  • Inicjalizuje Hibernate i tworzy schemat bazy danych.

Jeżeli którykolwiek z tych etapów zakończy się błędem, test nie przejdzie pomyślnie.

@SpringBootTest domyślnie nie uruchamia rzeczywistego serwera HTTP. Test weryfikuje poprawność inicjalizacji aplikacji, ale nie sprawdza jeszcze działania jej endpointów ani logiki biznesowej.

Testowanie repozytorium z PostgreSQL – @DataJpaTest

Kolejnym krokiem jest przetestowanie zapytania JPQL zdefiniowanego w OrderRepository. W tym celu utworzona zostanie osobna klasa OrderRepositoryIntegrationTest.

Zamiast @SpringBootTest wykorzystana zostanie adnotacja @DataJpaTest, która uruchamia jedynie część kontekstu Spring odpowiedzialną za JPA, encje i repozytoria. Dzięki temu nie ma potrzeby inicjalizowania kontrolerów ani serwisów.

W Spring Boot 4 wymagana jest dodatkowa zależność:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa-test</artifactId>
    <scope>test</scope>
</dependency>

Implementacja testu

@DataJpaTest
@Testcontainers
class OrderRepositoryIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer postgres =
        new PostgreSQLContainer("postgres:17-alpine");

    @Autowired
    OrderRepository repository;

    @Test
    void shouldCalculateOrderStatistics() {

        repository.saveAllAndFlush(List.of(
            new Order(1L, Order.Status.PAID,
                new BigDecimal("100.00")),
            new Order(1L, Order.Status.PAID,
                new BigDecimal("150.00")),
            new Order(1L, Order.Status.PAID,
                new BigDecimal("200.00")),
            new Order(1L, Order.Status.CANCELLED,
                new BigDecimal("500.00"))
        ));

        var stats = repository.findStats(
            1L, Order.Status.PAID, 2
        ).orElseThrow();

        assertThat(stats.getPaidOrders()).isEqualTo(3L);
        assertThat(stats.getTotalAmount())
            .isEqualByComparingTo(
                new BigDecimal("450.00"));

        assertThat(repository.findStats(
            1L, Order.Status.PAID, 4
        )).isEmpty();
    }
}

Test zapisuje cztery zamówienia w PostgreSQL, a następnie weryfikuje poprawność działania zapytania JPQL:

  • COUNT – liczba opłaconych zamówień wynosi 3.
  • SUM – łączna wartość opłaconych zamówień wynosi 450.
  • HAVING – zapytanie nie zwraca wyniku, jeżeli minimalna wymagana liczba zamówień wynosi 4.

Warto zwrócić uwagę, że @DataJpaTest domyślnie uruchamia każdy test w transakcji, która po jego zakończeniu jest wycofywana. Dzięki temu dane zapisane podczas testu nie pozostają w bazie.

Połączenie @DataJpaTest z Testcontainers pozwala testować rzeczywiste operacje na PostgreSQL bez uruchamiania całej aplikacji Spring Boot.

MockMvc – testowanie endpointów REST API

MockMvc to narzędzie udostępniane przez Spring Framework, które umożliwia testowanie endpointów HTTP bez konieczności uruchamiania rzeczywistego serwera.

Pozwala wykonywać żądania HTTP oraz weryfikować otrzymane odpowiedzi, np. kody statusów, nagłówki czy zawartość JSON.

W połączeniu z @SpringBootTest umożliwia testowanie całego przepływu żądania przez kontroler, serwis i repozytorium.

Zależności Maven

W Spring Boot 4 należy dodać starter odpowiedzialny za testowanie Spring MVC:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webmvc-test</artifactId>
    <scope>test</scope>
</dependency>

Starter zawiera między innymi obsługę MockMvc oraz narzędzia potrzebne do testowania aplikacji webowych.

Testowanie kontrolera

Istniejącą klasę CustomerIntegrationTest można rozszerzyć o adnotację @AutoConfigureMockMvc, która automatycznie konfiguruje obiekt MockMvc w kontekście Spring.

Pierwszy test sprawdzi scenariusz, w którym klient posiada mniej niż dwa opłacone zamówienia. Zgodnie z logiką aplikacji endpoint powinien zwrócić HTTP 404.

@SpringBootTest
@AutoConfigureMockMvc
@Testcontainers
class CustomerIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer postgres =
        new PostgreSQLContainer("postgres:17-alpine");

    @Autowired
    MockMvc mockMvc;

    @Autowired
    OrderRepository repository;

    @Test
    void contextLoads() {
    }

    @Test
    void shouldReturn404WhenCustomerHasTooFewOrders()
            throws Exception {

        repository.deleteAll();

        repository.saveAll(List.of(
            new Order(1L, Order.Status.PAID,
                new BigDecimal("100.00")),
            new Order(1L, Order.Status.CANCELLED,
                new BigDecimal("200.00"))
        ));

        mockMvc.perform(
                get("/api/customers/1/summary"))
            .andExpect(status().isNotFound());
    }
}

Test wykonuje następujące operacje:

  • Usuwa istniejące dane i zapisuje dwa zamówienia w PostgreSQL uruchomionym przez Testcontainers.
  • Wysyła żądanie GET /api/customers/1/summary za pomocą MockMvc.
  • Uruchamia rzeczywistą logikę kontrolera, serwisu i repozytorium.
  • Weryfikuje, czy odpowiedź ma status HTTP 404.

Ponieważ tylko jedno zamówienie ma status PAID, zapytanie JPQL nie spełnia warunku HAVING COUNT(o) >= 2. Serwis zgłasza więc wyjątek ResponseStatusException, który skutkuje odpowiedzią HTTP 404.

Warto zauważyć, że test nie korzysta z żadnych mocków obiektów Java. Repozytorium wykonuje rzeczywiste zapytanie do PostgreSQL, a MockMvc symuluje wyłącznie komunikację HTTP z aplikacją.

Zewnętrzne API nie jest jeszcze wywoływane, ponieważ metoda serwisowa kończy się wyjątkiem przed wykonaniem żądania przez CustomerClient.

WireMock – symulowanie zewnętrznego REST API

W poprzednim teście sprawdzona została współpraca kontrolera, serwisu i repozytorium z rzeczywistą bazą PostgreSQL. Kolejnym krokiem jest przetestowanie scenariusza, w którym aplikacja dodatkowo komunikuje się z zewnętrznym REST API.

Do tego celu wykorzystany zostanie WireMock – biblioteka umożliwiająca uruchomienie symulowanego serwera HTTP oraz definiowanie odpowiedzi na określone żądania.

Dzięki WireMock można testować komunikację HTTP bez konieczności uruchamiania rzeczywistego zewnętrznego serwisu.

Zależność Maven

Do pliku pom.xml należy dodać:

<dependency>
    <groupId>org.wiremock</groupId>
    <artifactId>wiremock</artifactId>
    <version>3.13.2</version>
    <scope>test</scope>
</dependency>

Konfiguracja WireMock

Istniejącą klasę CustomerIntegrationTest należy rozszerzyć o następujące elementy:

@RegisterExtension
static WireMockExtension wireMock =
    WireMockExtension.newInstance()
        .options(wireMockConfig().dynamicPort())
        .build();

@DynamicPropertySource
static void configureProperties(
        DynamicPropertyRegistry registry) {
    registry.add(
        "customer.api.base-url",
        wireMock::baseUrl
    );
}
  • @RegisterExtension – rejestruje rozszerzenie JUnit zarządzające serwerem WireMock.
  • dynamicPort() – uruchamia serwer HTTP na losowym, wolnym porcie.
  • @DynamicPropertySource – umożliwia dynamiczne nadpisanie właściwości Spring Boot.
  • wireMock::baseUrl – udostępnia adres uruchomionego serwera WireMock.

Dzięki tej konfiguracji CustomerClient będzie wysyłał żądania HTTP do WireMock zamiast do adresu zdefiniowanego w application.yml.

Pełny test integracyjny

Teraz można przygotować test pozytywnego scenariusza, w którym klient posiada trzy opłacone zamówienia, a zewnętrzne API zwraca jego dane.

Do istniejącej klasy CustomerIntegrationTest wystarczy dodać kolejną metodę:

@Test
void shouldReturnCustomerSummary() throws Exception {

    repository.deleteAll();

    repository.saveAll(List.of(
        new Order(1L, Order.Status.PAID,
            new BigDecimal("100.00")),
        new Order(1L, Order.Status.PAID,
            new BigDecimal("150.00")),
        new Order(1L, Order.Status.PAID,
            new BigDecimal("200.00")),
        new Order(1L, Order.Status.CANCELLED,
            new BigDecimal("500.00"))
    ));

    wireMock.stubFor(
        get(urlEqualTo("/customers/1"))
            .willReturn(okJson("""
                {
                    "name": "John Smith"
                }
                """))
    );

    mockMvc.perform(
            get("/api/customers/1/summary"))
        .andExpect(status().isOk())
        .andExpect(jsonPath("$.customerName")
            .value("John Smith"))
        .andExpect(jsonPath("$.paidOrders")
            .value(3))
        .andExpect(jsonPath("$.totalAmount")
            .value(450.0));

    wireMock.verify(
        getRequestedFor(urlEqualTo("/customers/1"))
    );
}

Test wykonuje następujące operacje:

  1. Testcontainers zapewnia dostęp do rzeczywistej bazy PostgreSQL, w której zapisywane są cztery przykładowe zamówienia.
  2. WireMock konfiguruje odpowiedź HTTP 200 z danymi klienta.
  3. MockMvc wykonuje żądanie GET /api/customers/1/summary.
  4. Spring Boot przetwarza żądanie przez kontroler, serwis, repozytorium oraz klienta HTTP.
  5. Asercje weryfikują poprawność kodu HTTP i zwróconego JSON.

Dodatkowo metoda wireMock.verify() sprawdza, czy aplikacja rzeczywiście wykonała żądanie do zewnętrznego API.

Warto zauważyć, że zamówienie o statusie CANCELLED nie zostało uwzględnione w wyniku. Potwierdza to poprawne działanie warunków zapytania JPQL.

W ten sposób powstał kompletny test integracyjny obejmujący wszystkie warstwy aplikacji, rzeczywistą bazę danych oraz symulowaną komunikację z zewnętrznym serwisem.

Co istotne, w teście nie zastosowano Mockito do zastępowania klas aplikacji. Wszystkie jej komponenty działają rzeczywiście, a WireMock zastępuje wyłącznie zewnętrzną usługę HTTP.

Testy parametryzowane repozytorium z PostgreSQL

W przypadku repozytoriów często zachodzi potrzeba przetestowania tego samego zapytania dla różnych kombinacji parametrów. Zamiast tworzyć osobne metody testowe, można wykorzystać @ParameterizedTest z JUnit 5.

Adnotacja ta pozwala wielokrotnie uruchomić ten sam test, przekazując do niego różne zestawy danych.

Przy okazji warto wykorzystać dwie dodatkowe adnotacje:

  • @BeforeEach – wykonuje przygotowanie danych przed każdym testem.
  • @AfterEach – wykonuje operacje porządkowe po każdym teście.

Implementacja OrderRepositoryIntegrationTest

@DataJpaTest
@Testcontainers
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class OrderRepositoryIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer postgres =
        new PostgreSQLContainer("postgres:17-alpine");

    @Autowired
    OrderRepository repository;

    @BeforeEach
    void setUp() {
        repository.saveAllAndFlush(List.of(
            new Order(1L, Order.Status.PAID,
                new BigDecimal("100.00")),
            new Order(1L, Order.Status.PAID,
                new BigDecimal("150.00")),
            new Order(1L, Order.Status.PAID,
                new BigDecimal("200.00")),
            new Order(1L, Order.Status.CANCELLED,
                new BigDecimal("500.00"))
        ));
    }

    @AfterEach
    void tearDown() {
        repository.deleteAll();
    }

    @ParameterizedTest
    @CsvSource({
        "PAID,      1, 3, 450.00",
        "PAID,      3, 3, 450.00",
        "PAID,      4, 0, 0.00",
        "CANCELLED, 1, 1, 500.00",
        "CANCELLED, 2, 0, 0.00"
    })
    void shouldCalculateOrderStatistics(
            Order.Status status,
            long minOrders,
            long expectedCount,
            String expectedTotal) {

        var result = repository.findStats(
            1L, status, minOrders
        );

        if (expectedCount == 0) {
            assertThat(result).isEmpty();
        } else {
            var stats = result.orElseThrow();

            assertThat(stats.getPaidOrders())
                .isEqualTo(expectedCount);

            assertThat(stats.getTotalAmount())
                .isEqualByComparingTo(
                    new BigDecimal(expectedTotal));
        }
    }
}

Adnotacja @CsvSource definiuje pięć zestawów parametrów, dla których JUnit automatycznie uruchomi metodę shouldCalculateOrderStatistics().

Każde uruchomienie wykonuje pełny cykl:

  1. @BeforeEach – zapisanie przykładowych zamówień.
  2. @ParameterizedTest – wykonanie zapytania i sprawdzenie wyniku.
  3. @AfterEach – usunięcie danych testowych.

Dzięki temu każdy przypadek testowy rozpoczyna się z takim samym zestawem danych.

Warto zwrócić uwagę na adnotację @Transactional(propagation = Propagation.NOT_SUPPORTED). Wyłącza ona domyślną transakcyjność testów @DataJpaTest, dzięki czemu zapisane dane nie są automatycznie wycofywane i ich usunięcie w @AfterEach ma rzeczywiste znaczenie.

W praktyce jednak najczęściej lepiej pozostawić domyślny mechanizm rollback udostępniany przez @DataJpaTest. Wówczas adnotacja @AfterEach nie jest potrzebna do czyszczenia bazy, ponieważ Spring automatycznie wycofa zmiany po zakończeniu każdego testu.

Dobre praktyki

Podczas tworzenia testów integracyjnych warto przestrzegać kilku zasad, które wpływają na ich niezawodność, czytelność i szybkość wykonywania.

  • Testowanie na rzeczywistych zależnościach – w przypadku baz danych warto wykorzystywać Testcontainers zamiast zamienników takich jak H2, szczególnie gdy aplikacja korzysta ze specyficznych funkcjonalności PostgreSQL.
  • Izolacja testów – każdy test powinien działać niezależnie od pozostałych. Dane testowe należy odpowiednio przygotowywać i usuwać lub korzystać z automatycznego wycofywania transakcji.
  • Ograniczanie zakresu kontekstu Spring – nie każdy test wymaga @SpringBootTest. W przypadku repozytoriów często wystarczy @DataJpaTest, a do testowania kontrolerów @WebMvcTest.
  • Unikanie zależności od zewnętrznych usług – wykorzystanie WireMock pozwala kontrolować odpowiedzi HTTP i eliminuje problemy wynikające z niedostępności rzeczywistego API.
  • Wykorzystanie testów parametryzowanych – @ParameterizedTest pozwala sprawdzić wiele wariantów działania tej samej funkcjonalności bez tworzenia osobnych metod testowych.
  • Kontrolowanie czasu wykonywania testów – warto ograniczać niepotrzebne uruchamianie kontekstów Spring oraz wykorzystywać współdzielenie kontenerów i mechanizm cache kontekstów testowych, o ile nie narusza to izolacji testów.

Dobrze zaprojektowane testy integracyjne powinny być przede wszystkim powtarzalne, niezależne od środowiska i skoncentrowane na rzeczywistym zachowaniu aplikacji.

Podsumowanie

Nowoczesne testowanie integracyjne aplikacji Spring Boot nie wymaga ręcznego przygotowywania rozbudowanego środowiska testowego. Dzięki narzędziom takim jak Testcontainers, MockMvc i WireMock możliwe jest automatyczne testowanie współpracy poszczególnych komponentów aplikacji.

W przedstawionym przykładzie Testcontainers umożliwił uruchomienie rzeczywistej bazy PostgreSQL, MockMvc pozwolił zweryfikować działanie endpointów REST API, natomiast WireMock posłużył do symulowania komunikacji z zewnętrznym serwisem.

Dodatkowo wykorzystanie @DataJpaTest oraz testów parametryzowanych JUnit 5 pozwoliło sprawdzić działanie repozytorium dla różnych scenariuszy bez konieczności uruchamiania całej aplikacji.

Źródła:

Spring Boot – Testing Spring Boot Applications

Spring Boot – Testcontainers

WireMock – JUnit Jupiter

JUnit 5 – Parameterized Tests

Dodaj komentarz