SpringBootTest_Mocks

1. O projekcie

• Prosta aplikacja Spring Boot w Java 17.
• Cel: zrozumienie podstawowych zasad tworzenia kontrolerów HTTP oraz testów jednostkowych i integracyjnych.
• Projekt jest zbudowany z użyciem Maven (pom.xml).

2. Co to są mocki i Mockito

• Mock to obiekt, który zachowuje się jak prawdziwy komponent, ale jego odpowiedzi są zdefiniowane w teście.
• Mockito to biblioteka Java służąca do tworzenia mocków i weryfikowania interakcji między obiektami.
• Dzięki mockom można testować fragmenty kodu w izolacji, bez zależności od zewnętrznych serwisów czy skomplikowanej konfiguracji.

3. Struktura projektu

• src/main/java/.../SpringBootTestMocksApplication.java – punkt wejścia aplikacji.
• src/main/java/.../HelloController.java – REST API z jednym endpointem.
• src/test/java/.../GreetingServiceTest.java – test z użyciem Mockito.
• src/test/java/.../HelloControllerTest.java – test kontrolera z MockMvc.
• src/test/java/.../SpringBootTestMocksApplicationTests.java – podstawowy test ładowania kontekstu.

3. pom.xml - zależności i wersje

Kluczowe zależności:

• spring-boot-starter-web – serwis webowy, Spring MVC.
• spring-boot-starter-test – zestaw testowy Spring Boot.
• mockito-core – biblioteka do mockowania zależności.
• mockito-all – starsza wersja Mockito, raczej odziedziczona.

Wersja Java: 17.

4. SpringBootTestMocksApplication.java – uruchomienie aplikacji

package pl.com.pl.springboottest_mocks;

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

@SpringBootApplication // automatyczna konfiguracja i skanowanie komponentów
public class SpringBootTestMocksApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootTestMocksApplication.class, args); // uruchomienie aplikacji
    }
}

• @SpringBootApplication łączy konfigurację, automatyczną konfigurację i skan komponentów.
• SpringApplication.run(...) uruchamia wbudowany serwer Tomcat.

5. HelloController.java – prosty kontroler REST

package pl.com.pl.springboottest_mocks;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // kontroler REST zwracający dane bez widoków
public class HelloController {
    @GetMapping("/hello") // obsługa żądania GET pod adresem /hello
    public String hello() {
        return "Hello, world!"; // zwraca prosty tekst jako odpowiedź
    }
}

• @RestController oznacza komponent Spring, który zwraca dane jako HTTP response.
• @GetMapping("/hello") mapuje żądanie GET na metodę hello().
• Metoda zwraca prosty tekst: Hello, world!.

6. GreetingServiceTest.java – unit test z mockiem

package pl.com.pl.springboottest_mocks;

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

class GreetingService {
    String greet(String name) { // metoda generująca powitanie
        return "Hello, " + name;
    }
}

@SpringBootTest
public class GreetingServiceTest {

    @Test
    void testGreetingWithMock() {
        GreetingService mockService = Mockito.mock(GreetingService.class); // tworzenie atrapy serwisu
        when(mockService.greet("Artur")).thenReturn("Cześć Artur"); // ustalenie zachowania mocka

        String result = mockService.greet("Artur"); // wywołanie metody na mocku

        assertEquals("Cześć Artur", result); // porównanie wyniku z oczekiwanym
        verify(mockService).greet("Artur"); // sprawdzenie, że metoda została wywołana
    }
}

Nauka z tego testu:

• Tworzymy mocka klasy GreetingService.
• Ustawiamy zachowanie metody greet(...) przy konkretnym argumencie.
• Sprawdzamy, że metoda zwróciła oczekiwany tekst.
• Weryfikujemy wywołanie metody verify(...).

Uwaga: Ten test pokazuje technikę mockowania, ale nie testuje rzeczywistej implementacji metody greet.

7. HelloControllerTest.java – test warstwy webowej

package pl.com.pl.springboottest_mocks;

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.*;

@SpringBootTest // ładowanie pełnego kontekstu Spring
@AutoConfigureMockMvc // konfiguracja MockMvc do testowania bez serwera
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc; // narzędzie do symulowania żądań HTTP

    @Test
    void shouldReturnHelloWorld() throws Exception {
        mockMvc.perform(get("/hello")) // symulacja żądania GET
                .andExpect(status().isOk()) // oczekiwanie kodu 200
                .andExpect(content().string("Hello, world!")); // oczekiwanie treści odpowiedzi
    }
}

Kluczowe punkty:

• @SpringBootTest ładuje kontekst aplikacji.
• @AutoConfigureMockMvc konfiguruje MockMvc do testowania kontrolerów bez uruchamiania serwera HTTP.
• Test wykonuje żądanie GET na /hello i sprawdza kod odpowiedzi oraz zawartość.

8. SpringBootTestMocksApplicationTests.java – sanity check

package pl.com.pl.springboottest_mocks;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest // test sprawdzający, czy kontekst Spring się zbuduje
class SpringBootTestMocksApplicationTests {
    @Test
    void contextLoads() {
    }
}

• Test weryfikuje, że kontekst Spring Boot się buduje bez błędów.
• Przydatny jako podstawowy test integracyjny.

9. Pojęcia i wyjaśnienia kodu

• @SpringBootApplication to punkt startowy aplikacji. Łączy trzy mechanizmy:

  • @Configuration oznacza klasę jako źródło beanów,
  • @EnableAutoConfiguration pozwala Spring Boot automatycznie skonfigurować komponenty na podstawie zależności,
  • @ComponentScan skanuje pakiety w poszukiwaniu komponentów, kontrolerów i serwisów. Dzięki temu w większości prostych projektów nie trzeba ręcznie pisać konfiguracji Spring.

• HelloController to prosty kontroler REST. @RestController deklaruje komponent webowy, a @GetMapping("/hello") mapuje żądanie GET na metodę hello(). Metoda zwraca zwykły tekst, który Spring automatycznie umieszcza w ciele odpowiedzi HTTP.

• src/main/java zawiera kod aplikacyjny, a src/test/java zawiera testy sprawdzające ten kod. Testy są oddzielnym produktem, który pomaga utrzymać jakość i poprawność działania aplikacji.

• W GreetingServiceTest pokazano mockowanie. mockito tworzy atrapę GreetingService, więc metoda greet nie jest wywoływana na rzeczywistej instancji. Dzięki temu można ustalić oczekiwane zachowanie i przetestować logikę w izolacji.

• HelloControllerTest używa MockMvc, aby zweryfikować warstwę webową bez uruchamiania rzeczywistego serwera HTTP. MockMvc wysyła symulowane żądanie GET do kontrolera i sprawdza, czy odpowiedź ma status 200 OK oraz zawiera Hello, world!.

• contextLoads() to test konfiguracji, a nie funkcjonalności. Jego zadaniem jest sprawdzić, czy Spring Boot potrafi prawidłowo zainicjować kontekst aplikacji. Gdyby wystąpił problem z konfiguracją, zależnościami lub beanami, test ten się nie powiedzie.

• Testy jednostkowe a integracyjne:

  • testy jednostkowe kontrolują pojedyncze klasy lub metody w izolacji,
  • testy integracyjne sprawdzają współdziałanie komponentów i konfigurację Spring,
  • w tym projekcie oba podejścia są obok siebie, bo mocki pokazują izolację logiki, a MockMvc i SpringBootTest pokazują zachowanie całego stosu webowego.

10. Najważniejsze wnioski

• Projekt jest prosty i świetny do nauki podstaw Spring Boot.
• Pokazuje jednocześnie działanie kontrolera REST i technikę mockowania.
• Testy ilustrują praktyczne podejście do testowania aplikacji webowej.
• To dobry przykład na rozpoczęcie pracy z Spring Boot i testowania w Javie.