Spring Boot｜@WebMvcTestと@SpringBootTestの違いと使い分け

import org.springframework.test.context.bean.override.mockito.MockitoBean;

// テストクラス内のフィールド
@MockitoBean
GreetingService greetingService;

import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
class GreetingApplicationTest {
    // MockMvcを注入して検証する
}

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

package com.example.greeting;

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

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

package com.example.greeting;

import org.springframework.stereotype.Service;

@Service
public class GreetingService {
    public String greet(String name) {
        String normalized = name.strip();
        if ("admin".equalsIgnoreCase(normalized)) {
            throw new RejectedNameException();
        }
        return "Hello, " + normalized + "!";
    }

    public static class RejectedNameException extends RuntimeException {
    }
}

package com.example.greeting;

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {
    private final GreetingService greetingService;

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

    @PostMapping("/greetings")
    public GreetingResponse greet(@Valid @RequestBody GreetingRequest request) {
        return new GreetingResponse(greetingService.greet(request.name()));
    }

    public record GreetingRequest(@NotBlank String name) {
    }

    public record GreetingResponse(String message) {
    }
}

package com.example.greeting;

import java.util.Map;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GreetingExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidation(
            MethodArgumentNotValidException exception) {
        return ResponseEntity.badRequest()
                .body(Map.of("code", "INVALID_NAME"));
    }

    @ExceptionHandler(GreetingService.RejectedNameException.class)
    public ResponseEntity<Map<String, String>> handleRejectedName(
            GreetingService.RejectedNameException exception) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
                .body(Map.of("code", "NAME_REJECTED"));
    }
}

package com.example.greeting;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(GreetingController.class)
class GreetingControllerWebMvcTest {
    @Autowired
    MockMvc mockMvc;

    @MockitoBean
    GreetingService greetingService;

    @Test
    void returnsServiceResultAsJson() throws Exception {
        when(greetingService.greet("mikan")).thenReturn("from-service");

        mockMvc.perform(post("/greetings")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {"name":"mikan"}
                                """))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.message").value("from-service"));

        verify(greetingService).greet("mikan");
    }
}

package com.example.greeting;

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.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
class GreetingApplicationTest {
    @Autowired
    MockMvc mockMvc;

    @Test
    void returnsGreetingFromRealService() throws Exception {
        mockMvc.perform(post("/greetings")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {"name":" mikan "}
                                """))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.message").value("Hello, mikan!"));
    }
}

package com.example.greeting;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class GreetingHttpTest {
    @Autowired
    TestRestTemplate restTemplate;

    @Test
    void returnsGreetingOverHttp() {
        ResponseEntity<GreetingController.GreetingResponse> response =
                restTemplate.postForEntity(
                        "/greetings",
                        new GreetingController.GreetingRequest(" mikan "),
                        GreetingController.GreetingResponse.class);

        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertNotNull(response.getBody());
        assertEquals("Hello, mikan!", response.getBody().message());
    }
}

@Test
void rejectsBlankNameBeforeCallingService() throws Exception {
    mockMvc.perform(post("/greetings")
                    .contentType(MediaType.APPLICATION_JSON)
                    .content("""
                            {"name":"   "}
                            """))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.code").value("INVALID_NAME"));

    org.mockito.Mockito.verifyNoInteractions(greetingService);
}

@Test
void convertsServiceExceptionToConflict() throws Exception {
    when(greetingService.greet("admin"))
            .thenThrow(new GreetingService.RejectedNameException());

    mockMvc.perform(post("/greetings")
                    .contentType(MediaType.APPLICATION_JSON)
                    .content("""
                            {"name":"admin"}
                            """))
            .andExpect(status().isConflict())
            .andExpect(jsonPath("$.code").value("NAME_REJECTED"));
}

@Test
void rejectsReservedNameThroughRealService() throws Exception {
    mockMvc.perform(post("/greetings")
                    .contentType(MediaType.APPLICATION_JSON)
                    .content("""
                            {"name":"admin"}
                            """))
            .andExpect(status().isConflict())
            .andExpect(jsonPath("$.code").value("NAME_REJECTED"));
}