For AI agents: the complete documentation index is available at /Practical-Introduction-to-Spring-Boot/llms.txt, the full documentation bundle is available at /Practical-Introduction-to-Spring-Boot/llms-full.txt, and this page is available as Markdown at /Practical-Introduction-to-Spring-Boot/SpringBootテスト入門/バリデーションテスト.md.

Spring Boot のバリデーションを題材にしたテスト入門

講義の区切り

基本編の目安は 90 分です。終了条件は「DTO の境界値と Web の400を検証」です。 基本編には ParameterizedTest による境界値の検証を含めます。90分の配分は、準備・対象コード20分、DTO と ParameterizedTest 35分、Web の400確認25分、振り返り10分です。 発展内容・次回の目安: Advice の独立テスト。基本の確認後に取り組んでください。 準備と前後の章は 学習ガイド で確認できます。

はじめに

テスト入門 では、アノテーションとアサーションを使ってテストを実装しました。

今回は境界値分析というテスト技法を使ったバリデーションのテストと、 コントローラー・アドバイスのテストを実施してみましょう。

前提知識と到達目標

バリデーション入門 の @Valid と制約アノテーションを理解している方が対象です。 Java 21 と Maven Wrapper を用意し、次のリンクで別プロジェクトを作ります。 実装は src/main/java、テストは src/test/java の指定された場所に配置します。

次の順で検証します。

テスト確認すること
DTO制約と境界値が正しいか
ControllerHTTP リクエストで検証が実行されるか
Advice(発展)例外が決めた JSON 形式に変換されるか

Advice のテストは発展内容です。基本編の 90 分では DTO と Controller までを確認し、時間があれば取り組んでください。

この分担を使って、ひとつの不具合が起きたときに、どのテストで確認すべきか判断できることを目指します。

Spring Initializr

Java 21 / Spring Web / Validation / Lombok のプロジェクトを作成

生成前に Spring Boot が 4.0 系であることを確認します。4.0.2 が表示されない場合は、利用可能な 4.0 系の安定版を選んでください。

pom.xml に spring-boot-starter-webmvc-test(scope は test)があることを確認してください。無い場合は dependencies に次を追加します。

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

この教材は Spring Boot 4.0 系と Jackson 3(tools.jackson)の例です。 3.x 系のコードを混ぜると import や JSON 変換の API が異なるため、指定プロジェクトで進めてください。

テスト対象のソースコード

ユーザー作成エンドポイントを想定した、空実装のコードと、バリデーションエラーをハンドリングする RestControllerAdvice を用意しました。

DTO

UserCreateRequest.java

リクエスト側には、アノテーションでバリデーションの制約を定義しています。

src/main/java/dev/mikoto2000/handson/springboot/test/firststep/user/dto/UserCreateRequest.java:

package dev.mikoto2000.handson.springboot.test.firststep.user.dto;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@Data
@NoArgsConstructor
public class UserCreateRequest {

    @NotBlank(message = "username は必須です")
    @Size(min = 3, max = 20, message = "username は 3〜20 文字で入力してください")
    private String username;

    @NotBlank(message = "email は必須です")
    @Email(message = "email の形式が不正です")
    private String email;

    @NotBlank(message = "password は必須です")
    @Size(min = 8, max = 100, message = "password は 8〜100 文字で入力してください")
    private String password;
}

UserCreateResponse.java

レスポンス側は特にバリデーションの制約は無いので、ただの DTO になっています。

src/main/java/dev/mikoto2000/handson/springboot/test/firststep/user/dto/UserCreateResponse.java:

package dev.mikoto2000.handson.springboot.test.firststep.user.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@Data
@NoArgsConstructor
public class UserCreateResponse {

    private Long id;
    private String username;
    private String email;

}

Controller

今回は、バリデーションのテストの練習なので、サービス呼び出しなどはせず、適当にレスポンスを返すだけのコントローラーにしています。

src/main/java/dev/mikoto2000/handson/springboot/test/firststep/user/controller/UserController.java:

package dev.mikoto2000.handson.springboot.test.firststep.user.controller;

import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import dev.mikoto2000.handson.springboot.test.firststep.user.dto.UserCreateRequest;
import dev.mikoto2000.handson.springboot.test.firststep.user.dto.UserCreateResponse;

@RestController
@RequestMapping("/users")
public class UserController {

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public UserCreateResponse create(@RequestBody @Valid UserCreateRequest request) {
        // 教材用なのでサービス呼び出しは省略、適当にレスポンスを組み立てて返却
        return new UserCreateResponse(1L, request.getUsername(), request.getEmail());
    }
}

RestControllerAdvice

MethodArgumentNotValidException を ApiErrorResponse に変換する RestControllerAdvice クラスを用意しました。 この章では独自 DTO の code・message・errors を検証します。例外処理・エラー応答入門 の ProblemDetail を使う場合も、テストで実際の応答契約を確認する考え方は同じです。

DTO

エラーレスポンスの形式を定義する DTO クラスを用意しました。

src/main/java/dev/mikoto2000/handson/springboot/test/firststep/common/dto/ApiErrorResponse.java:

package dev.mikoto2000.handson.springboot.test.firststep.common.dto;

import java.util.List;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;


@AllArgsConstructor
@Data
@NoArgsConstructor
public class ApiErrorResponse {
    private String code;
    private String message;
    private List<ValidationErrorDetail> errors;
}

また、バリデーションエラーの詳細を表す DTO クラスも用意しました。

src/main/java/dev/mikoto2000/handson/springboot/test/firststep/common/dto/ValidationErrorDetail.java:

package dev.mikoto2000.handson.springboot.test.firststep.common.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@Data
@NoArgsConstructor
public class ValidationErrorDetail {
    private String field;
    private String message;
}

Advice クラス

エラーを横断的にハンドリングする RestControllerAdvice クラスを用意しました。

src/main/java/dev/mikoto2000/handson/springboot/test/firststep/common/advice/ApiExceptionHandler.java:

package dev.mikoto2000.handson.springboot.test.firststep.common.advice;

import java.util.List;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import dev.mikoto2000.handson.springboot.test.firststep.common.dto.ApiErrorResponse;
import dev.mikoto2000.handson.springboot.test.firststep.common.dto.ValidationErrorDetail;

@RestControllerAdvice
public class ApiExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ApiErrorResponse handleMethodArgumentNotValid(MethodArgumentNotValidException e) {
        List<ValidationErrorDetail> errors = e.getBindingResult()
                .getFieldErrors()
                .stream()
                .map(e2 -> new ValidationErrorDetail(e2.getField(), e2.getDefaultMessage()))
                .toList();

        return new ApiErrorResponse(
                "VALIDATION_ERROR",
                "入力値が不正です",
                errors
        );
    }
}

動作確認

次のコマンドでアプリケーションを起動し、正常系と異常系のリクエストを送ってみましょう。

./mvnw spring-boot:run

正常系リクエスト:

curl -i -X POST \
    -H 'Content-Type: application/json' \
    http://localhost:8080/users \
    -d '{"username":"test", "email":"test@gmail.com", "password": "abcdefgh"}'

異常系リクエスト:

curl -i -X POST \
    -H 'Content-Type: application/json' \
    http://localhost:8080/users \
    -d '{"username":"", "email":"test@gmail.com", "password": "abcdefgh"}'

正常系は 201 と id / username / email、異常系は 400 と code=VALIDATION_ERROR が返れば成功です。 空の username は @NotBlank と @Size の両方に違反するため、errors は 2 件になります。 エラーの並び順は固定しません。 ここでは DB への登録は行っていないため、201 は教材の疑似的な応答です。

テストコード

DTO のバリデーションテスト

リクエストの DTO クラスのバリデーションを、Spring を起動せずに検証するテストコードを用意します。

String の @Size は UTF-16 コードユニット単位の String.length() を数えます。ASCII の境界値に加え、絵文字11コードポイントが長さ22になるケースも確認します。見た目の文字数、コードポイント数、UTF-8 バイト数を区別しましょう。

バリデーターを直接呼び出すことで、DTO クラスのバリデーションの制約が期待通りに定義されているかを確認します。

まずは正常系の @Test で「違反なし」を確認し、その後に境界値を追加します。 @Nested は関連するテストのグループ化、@ParameterizedTest は同じ検証を複数の入力で繰り返す仕組みです。 @MethodSource は入力と期待結果を返すメソッドを指定します。 以下では username の 2 / 3 / 20 / 21 文字を使い、最小値・最大値の内外を確認します。

src/test/java/dev/mikoto2000/handson/springboot/test/firststep/user/dto/UserCreateRequestTest.java:

講義では UserCreateRequestTest の責務と確認する結果に注目します。実装時には次の完成コードを開いて配置してください。

注目するのは、期待する違反をテスト名と assertion で固定する部分です。

抜粋: DTO の検証結果を確認する
var violations = validator.validate(request);
assertFalse(violations.isEmpty());
UserCreateRequestTest の完成コード
package dev.mikoto2000.handson.springboot.test.firststep.user.dto;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.Set;
import java.util.stream.Stream;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;

/**
 * DTO の Bean Validation を Spring を起動せずに検証するテスト。
 */
@DisplayName("UserCreateRequest の Bean Validation")
class UserCreateRequestTest {

  // バリデーションを実行するためのバリデーター
  private static Validator validator;
  private static ValidatorFactory factory;

  // 全テストの前に一度だけ実行する処理
  @BeforeAll
  static void setUp() {
    // バリデーターを生成
    factory = Validation.buildDefaultValidatorFactory();
    validator = factory.getValidator();
  }

  @AfterAll
  static void tearDown() {
    factory.close();
  }

  @Nested
  @DisplayName("正常系")
  class NormalCases {
    @Test
    void test妥当な値なら違反なし() {

      // Arrange
      UserCreateRequest request = new UserCreateRequest(
          "test",
          "test@example.com",
          "password123"
          );

      // Act
      Set<ConstraintViolation<UserCreateRequest>> violations = validator.validate(request);

      // Assert
      assertTrue(violations.isEmpty(), "違反は0件のはず");
    }
  }

  @Nested
  @DisplayName("異常系")
  class ErrorCases {

    // username の文字数は境界値で確認。null・空文字・空白のみは別の必須ケースとして追加する

    @Test
    void testEmailの形式が不正なら違反() {
      // Arrange:
      // email だけ不正にし、他の項目は妥当値に固定する
      UserCreateRequest request = new UserCreateRequest(
          "test",
          "abc",
          "password123"
          );

      // Act
      Set<ConstraintViolation<UserCreateRequest>> violations = validator.validate(request);

      // Assert 1:
      // 今回は email だけを不正にしているので、違反が返るはず
      assertFalse(violations.isEmpty(), "違反があるはず");

      // Assert 2:
      // email に対する違反であることを propertyPath で確認する
      boolean emailPathFound = violations.stream()
        .map(ConstraintViolation::getPropertyPath)
        .anyMatch(path -> path.toString().equals("email"));

      assertTrue(emailPathFound, "email の違反があるはず");
    }

    // password の文字数境界と必須ケースは、後の練習で追加する
  }

  @Nested
  @DisplayName("境界値")
  class BoundaryCases {

    @Test
    void test補助文字はUTF16の長さで検証される() {
      String username = "😀".repeat(11);
      assertEquals(11, username.codePointCount(0, username.length()));
      assertEquals(22, username.length());
      var request = new UserCreateRequest(username, "test@example.com", "password123");
      var violations = validator.validate(request);
      assertEquals(1, violations.size());
      assertEquals("username", violations.iterator().next().getPropertyPath().toString());
    }

    @ParameterizedTest(name = "[{index}] {0}: username長={1} → username違反={2}")
    @MethodSource("dev.mikoto2000.handson.springboot.test.firststep.user.dto.UserCreateRequestTest#usernameLengthBoundaryCases")
    void testUsernameの文字数境界(String caseName, int usernameLength, boolean expectedViolation) {
      // Arrange:
      // username だけを境界値として変化させる
      // email / password は常に妥当値に固定し、判定対象を username に絞る
      String username = "a".repeat(usernameLength);
      UserCreateRequest request = new UserCreateRequest(
          username,           // MethodSource により変化する
          "test@example.com", // 常に妥当
          "password123"       // 常に妥当
          );

      // Act: Bean Validation を実行
      Set<ConstraintViolation<UserCreateRequest>> violations = validator.validate(request);

      // Assert 1:
      // 今回は username だけを変化させているため、違反の有無をそのまま username の判定結果として扱える。
      boolean actualViolation = !violations.isEmpty();

      assertEquals(
          expectedViolation,
          actualViolation,
          "case=" + caseName + ", usernameLength=" + usernameLength + " の判定が期待と異なる"
          );

      // Assert 2:
      // propertyPath に username が含まれるかを確認する。
      boolean usernamePathFound = violations.stream()
        .map(ConstraintViolation::getPropertyPath)
        .anyMatch(path -> path.toString().equals("username"));

      assertEquals(
          expectedViolation,
          usernamePathFound,
          "case=" + caseName + ", usernameLength=" + usernameLength + " のパスが期待と異なる"
          );
    }
  }

  /**
   * username の境界値ケースを供給する。
   *
   * 引数の意味:
   *  1列目: ケース名(説明用)
   *  2列目: username の文字数
   *  3列目: username に違反が期待されるか(true=違反あり)
   *
   * 今回の制約:
   *  - username は 3〜20 文字
   */
  static Stream<Arguments> usernameLengthBoundaryCases() {
    return Stream.of(
        Arguments.of("最小値-1", 2, true),
        Arguments.of("最小値",   3, false),
        Arguments.of("最大値",   20, false),
        Arguments.of("最大値+1", 21, true)
        );
  }

  // TODO: 他の項目の境界値
}

DTO テストの実行と練習

./mvnw test -Dtest=UserCreateRequestTest を実行し、すべて成功することを確認します。 境界値の確認だけでは @NotBlank を十分に検証できません。次のケースを追加してみましょう。

  • username: null、空文字、空白 3 文字はいずれも違反
  • password: 7 / 8 / 100 / 101 文字は、順に違反あり / なし / なし / あり
  • email / password: null と空文字はいずれも必須違反

他の項目は常に妥当な値に固定し、どの項目の違反かを確認します。

Controller のテスト

コントローラーのテストコードを用意します。

MockMvc を使って、HTTP リクエストをシミュレートし、 コントローラーの入力バリデーションが期待通りに動作するかを確認します。

正常系のテストでは、妥当なリクエストを送って 201 が返ることと、レスポンスの内容が期待通りであることを確認します。

ここでは MVC 構成で Advice が適用されることを、400 と本文の code で確認します。 エラーの項目名やメッセージの詳細は、後述の独立した Advice テストで検証します。

src/test/java/dev/mikoto2000/handson/springboot/test/firststep/user/controller/UserControllerTest.java:

講義では UserControllerTest の責務と確認する結果に注目します。実装時には次の完成コードを開いて配置してください。

UserControllerTest の完成コード
package dev.mikoto2000.handson.springboot.test.firststep.user.controller;

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


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;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import java.nio.charset.StandardCharsets;

import dev.mikoto2000.handson.springboot.test.firststep.user.dto.UserCreateRequest;
import dev.mikoto2000.handson.springboot.test.firststep.user.dto.UserCreateResponse;
import tools.jackson.databind.json.JsonMapper;

/**
 * UserController の入力バリデーションを HTTP 層で検証するテスト。
 *
 * DTO 単体テストでは制約そのものを確認し、
 * ここでは @RequestBody + @Valid により想定した HTTP ステータスコードが返ることを確認する。
 * エラーレスポンスの形式は ApiExceptionHandlerTest で確認する。
 */
@WebMvcTest(UserController.class)
class UserControllerTest {

  @Autowired
  private MockMvc mockMvc;

  @Autowired
  private JsonMapper jsonMapper;

  @Nested
  @DisplayName("正常系")
  class NormalCase {
    @Test
    void test妥当なリクエストで201が返る() throws Exception {
      var request = new UserCreateRequest(
          "test",
          "test@example.com",
          "password123"
          );

      var body = jsonMapper.writeValueAsString(request);

      MvcResult result = mockMvc.perform(post("/users")
          .contentType(MediaType.APPLICATION_JSON)
          .content(body))
        // HTTP ステータスの確認
        .andExpect(status().isCreated())
        .andReturn();

      // 期待通りの型か、JsonMapper で変換することにより確認する
      UserCreateResponse response = assertDoesNotThrow(
          () -> jsonMapper.readValue(result.getResponse().getContentAsString(StandardCharsets.UTF_8), UserCreateResponse.class),
          "UserCreateResponse に変換できるはず");

      // 型の内容が期待通りか確認する
      assertEquals(1L, response.getId());
      assertEquals("test", response.getUsername());
      assertEquals("test@example.com", response.getEmail());
    }
  }

  @Nested
  @DisplayName("異常系")
  class ErrorCase {
    @Test
    void test不正なリクエストで400が返る() throws Exception {
      var request = new UserCreateRequest(
          "",
          "test@example.com",
          "password123"
          );

      var body = jsonMapper.writeValueAsString(request);

      mockMvc.perform(post("/users")
          .contentType(MediaType.APPLICATION_JSON)
          .content(body))
        .andExpect(status().isBadRequest())
        .andExpect(jsonPath("$.code").value("VALIDATION_ERROR"));
    }
  }
}

./mvnw test -Dtest=UserControllerTest で確認します。 DTO のテストが成功しても、このテストが失敗するなら、@Valid の付け忘れや HTTP の設定を調べられます。

Advice のテスト(発展)

コントローラーアドバイスのテストコードを用意します。基本編の 90 分では必須ではありません。

ここでは、例外発生時に返却されるエラーレスポンスの形式を検証することに集中します。

また、スタンドアロンの MockMvc を使って、コントローラーとアドバイスを明示的に登録してテストします。 @WebMvcTest では Spring が構成した JsonMapper を使います。この節では Spring のコンテキストを読み込まず、テスト内で JsonMapper を生成して本文を読み取ります。 DTO テストは Jakarta Validation の既定ファクトリ、@WebMvcTest は Spring の MVC 構成、スタンドアロンのテストは MockMvc の既定構成で検証します。言語別メッセージを導入した場合は、HTTP の言語切り替えを MVC 構成のテストで確認します。 この例の日本語メッセージはソースコードに直接記述しています。制約メッセージを {キー名} に変更した場合は、テストの言語と解決後の期待値を合わせてください。

src/test/java/dev/mikoto2000/handson/springboot/test/firststep/common/advice/ApiExceptionHandlerTest.java:

講義では ApiExceptionHandlerTest の責務と確認する結果に注目します。実装時には次の完成コードを開いて配置してください。

ApiExceptionHandlerTest の完成コード
package dev.mikoto2000.handson.springboot.test.firststep.common.advice;

import java.nio.charset.StandardCharsets;

import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.springframework.http.MediaType.APPLICATION_JSON;
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.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import dev.mikoto2000.handson.springboot.test.firststep.common.advice.ApiExceptionHandler;
import dev.mikoto2000.handson.springboot.test.firststep.common.dto.ApiErrorResponse;
import dev.mikoto2000.handson.springboot.test.firststep.user.dto.UserCreateRequest;
import jakarta.validation.Valid;
import tools.jackson.databind.json.JsonMapper;

/**
 * ApiExceptionHandler を standalone MockMvc で直接検証するテスト。
 *
 * Controller 本体の実装には依存せず、
 * 例外 -> エラーレスポンス形式への変換ロジックを確認する。
 */
@DisplayName("ApiExceptionHandler のテスト")
class ApiExceptionHandlerTest {

  private MockMvc mockMvc;

  private JsonMapper jsonMapper;

  @BeforeEach
  void setUp() {
    // JsonMapper を生成(Spring の DI に依存しない)
    jsonMapper = new JsonMapper();

    // テスト用 Controller + Advice を明示登録して MockMvc を構築
    mockMvc = MockMvcBuilders.standaloneSetup(new TestController())
        .setControllerAdvice(new ApiExceptionHandler())
        .build();
  }

  @Test
  void testバリデーションエラー時にApiErrorResponseを返す() throws Exception {
    // Arrange:
    // username を空にして、@Valid によるバリデーションエラーを発生させる
    var request = new UserCreateRequest(
        "",
        "test@example.com",
        "password123"
        );

    String body = jsonMapper.writeValueAsString(request);

    // Act:
    // ダミー Controller を叩く(@Valid で例外発生 -> Advice が処理)
    MvcResult result = mockMvc.perform(post("/test/users")
            .contentType(APPLICATION_JSON)
            .content(body))
        .andExpect(status().isBadRequest())
        .andReturn();

    // Assert 1:
    // レスポンス JSON を ApiErrorResponse に変換できることを確認
    ApiErrorResponse response = assertDoesNotThrow(
        () -> jsonMapper.readValue(result.getResponse().getContentAsString(StandardCharsets.UTF_8), ApiErrorResponse.class),
        "ApiErrorResponse に変換できるはず"
        );

    // Assert 2:
    // Advice が組み立てたエラー応答の固定項目を確認
    assertEquals("VALIDATION_ERROR", response.getCode());
    assertEquals("入力値が不正です", response.getMessage());

    // Assert 3:
    // username に NotBlank と Size の両方が付いているので 2 件
    assertEquals(2, response.getErrors().size(), "username のエラーは 2 件のはず");
    assertTrue(response.getErrors().stream()
        .allMatch(error -> "username".equals(error.getField())));
    var messages = response.getErrors().stream()
        .map(error -> error.getMessage())
        .collect(java.util.stream.Collectors.toSet());
    assertEquals(java.util.Set.of("username は必須です", "username は 3〜20 文字で入力してください"), messages);
  }

  /**
   * Advice テスト用のダミー Controller
   *
   * @Valid により MethodArgumentNotValidException を発生させるためだけに使う。
   */
  @RestController
  static class TestController {

    @PostMapping("/test/users")
    void create(@RequestBody @Valid UserCreateRequest request) {
      // バリデーションエラーを起こすことが目的なので、正常時の処理は不要
    }
  }
}

テスト全体の確認

発展の Advice テストまで進んだ場合は ./mvnw test -Dtest=ApiExceptionHandlerTest で応答形式を確認し、最後に ./mvnw test ですべてを実行します。基本編の 90 分では、DTO と Controller のテストまでで終了条件を満たします。 Advice のテストではテスト用 Controller を登録し、実際の検証例外を発生させています。 JSON に変換できるだけでなく、エラーの field / message も期待する内容かを確認しましょう。

まとめ

ここまでで、バリデーションのテスト構成・テスト方法について説明しました。

  • DTO クラスのバリデーションの制約を、Spring を起動せずに直接検証するテスト
  • コントローラーの入力バリデーションが、HTTP リクエストに対して期待通りに動作することを確認するテスト
  • コントローラーアドバイスが、例外発生時に期待通りのエラーレスポンスを返すことを確認するテスト(発展)

1つのテストで制約・HTTP・エラーレスポンス形式をすべて確認しようとせず、責務ごとに分けて検証するのがポイントです。

最後に、制約を変える場合、@Valid を外した場合、応答形式を変える場合で、どのテストが失敗するかを説明してみてください。

DTO, Controller, Advice それぞれのテストの責務と役割を理解し、適切にテストコードを書いていきましょう。