오류 코드와 메시지

package board.errorcodes;

import java.time.LocalDate;

public final class PostForm {
    private String content;
    private LocalDate publishedOn;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public LocalDate getPublishedOn() {
        return publishedOn;
    }

    public void setPublishedOn(LocalDate publishedOn) {
        this.publishedOn = publishedOn;
    }
}

package board.errorcodes;

import java.time.Clock;
import java.time.LocalDate;
import java.util.Objects;
import org.springframework.validation.Errors;

public final class PostDatePolicy {
    private final Clock clock;

    public PostDatePolicy(Clock clock) {
        this.clock = Objects.requireNonNull(clock, "clock");
    }

    public void validate(PostForm form, Errors errors) {
        Objects.requireNonNull(form, "form");
        Objects.requireNonNull(errors, "errors");

        if (errors.hasFieldErrors("publishedOn")) {
            return;
        }
        if (form.getPublishedOn() == null) {
            errors.rejectValue(
                    "publishedOn",
                    "post.date.required",
                    "작성일을 입력하세요.");
            return;
        }
        if (form.getPublishedOn().isAfter(LocalDate.now(clock))) {
            errors.rejectValue(
                    "publishedOn",
                    "post.date.future",
                    "작성일은 오늘 이후일 수 없습니다.");
        }
    }
}

post.content.length.postCreate.content=본문은 {0}자 이하여야 합니다.
post.content.length=허용 범위 안의 값을 입력하세요.
post.time.order.postCreate=등록 기간의 시작과 끝을 확인하세요.
post.time.order=기간 순서를 확인하세요.
typeMismatch.postCreate.publishedOn=작성일은 연도-월-일 형식으로 입력하세요.
typeMismatch.java.time.LocalDate=날짜는 연도-월-일 형식으로 입력하세요.
typeMismatch=입력 형식을 확인하세요.
post.date.required.postCreate.publishedOn=작성일을 입력하세요.
post.date.required=날짜를 입력하세요.
post.date.future.postCreate.publishedOn=작성일은 오늘 이후일 수 없습니다.
post.date.future=오늘 또는 이전 날짜를 입력하세요.

package board.errorcodes;

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

import java.nio.charset.StandardCharsets;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Locale;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.format.support.DefaultFormattingConversionService;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.DataBinder;
import org.springframework.validation.DefaultMessageCodesResolver;

class ErrorMessageResolutionTest {
    private static final Locale KOREAN = Locale.KOREAN;
    private static final Clock FIXED_CLOCK = Clock.fixed(
            Instant.parse("2026-03-10T00:00:00Z"),
            ZoneId.of("Asia/Seoul"));

    @Test
    void fieldErrorCandidatesRunFromObjectFieldToCommonRule() {
        var resolver = new DefaultMessageCodesResolver();

        var codes = resolver.resolveMessageCodes(
                "post.content.length",
                "postCreate",
                "content",
                String.class);

        assertThat(codes).containsExactly(
                "post.content.length.postCreate.content",
                "post.content.length.content",
                "post.content.length.java.lang.String",
                "post.content.length");
    }

    @Test
    void messageSourceSelectsTheMostSpecificFieldCodeAndFormatsArguments() {
        var result = bindingResult("postCreate");
        result.rejectValue(
                "content",
                "post.content.length",
                new Object[]{720},
                "본문 길이 오류");

        var error = result.getFieldError("content");

        assertThat(error).isNotNull();
        assertThat(error.getCodes()).containsExactly(
                "post.content.length.postCreate.content",
                "post.content.length.content",
                "post.content.length.java.lang.String",
                "post.content.length");
        assertThat(messageSource().getMessage(error, KOREAN))
                .isEqualTo("본문은 720자 이하여야 합니다.");
    }

    @Test
    void aDifferentObjectFallsBackToTheCommonRule() {
        var result = bindingResult("postEdit");
        result.rejectValue(
                "content",
                "post.content.length",
                new Object[]{720},
                "본문 길이 오류");

        assertThat(messageSource().getMessage(
                result.getFieldError("content"), KOREAN))
                .isEqualTo("허용 범위 안의 값을 입력하세요.");
    }

    @Test
    void allCandidatesMissingUseTheDefaultMessage() {
        var result = bindingResult("postCreate");
        result.rejectValue(
                "content",
                "post.content.unmapped",
                "등록할 수 없는 본문입니다.");

        var error = result.getFieldError("content");

        assertThat(error).isNotNull();
        assertThat(error.getCodes()).containsExactly(
                "post.content.unmapped.postCreate.content",
                "post.content.unmapped.content",
                "post.content.unmapped.java.lang.String",
                "post.content.unmapped");
        assertThat(messageSource().getMessage(error, KOREAN))
                .isEqualTo("등록할 수 없는 본문입니다.");
    }

    @Test
    void objectErrorUsesObjectSpecificThenCommonCandidates() {
        var result = bindingResult("postCreate");
        result.reject(
                "post.time.order",
                new Object[]{"publishedOn", "archivedOn"},
                "기간 순서 오류");

        var error = result.getGlobalError();

        assertThat(error).isNotNull();
        assertThat(error.getCodes()).containsExactly(
                "post.time.order.postCreate",
                "post.time.order");
        assertThat(messageSource().getMessage(error, KOREAN))
                .isEqualTo("등록 기간의 시작과 끝을 확인하세요.");
    }

    @Test
    void bindingFailureKeepsTypeMismatchAndSkipsTheDatePolicy() {
        var form = new PostForm();
        var binder = new DataBinder(form, "postCreate");
        binder.setConversionService(new DefaultFormattingConversionService());
        binder.bind(new MutablePropertyValues(Map.of(
                "publishedOn", "오늘")));

        var errors = binder.getBindingResult();
        var error = errors.getFieldError("publishedOn");

        assertThat(error).isNotNull();
        assertThat(error.getCodes()).containsExactly(
                "typeMismatch.postCreate.publishedOn",
                "typeMismatch.publishedOn",
                "typeMismatch.java.time.LocalDate",
                "typeMismatch");
        assertThat(messageSource().getMessage(error, KOREAN))
                .isEqualTo("작성일은 연도-월-일 형식으로 입력하세요.");

        new PostDatePolicy(FIXED_CLOCK).validate(form, errors);

        assertThat(errors.getFieldErrors("publishedOn")).hasSize(1);
        assertThat(errors.getFieldError("publishedOn").getCode())
                .isEqualTo("typeMismatch");
    }

    @Test
    void missingDateUsesRequiredCandidatesInsteadOfFutureCandidates() {
        var form = new PostForm();
        var errors = new BeanPropertyBindingResult(form, "postCreate");

        new PostDatePolicy(FIXED_CLOCK).validate(form, errors);

        var error = errors.getFieldError("publishedOn");
        assertThat(error).isNotNull();
        assertThat(error.getCodes()).containsExactly(
                "post.date.required.postCreate.publishedOn",
                "post.date.required.publishedOn",
                "post.date.required.java.time.LocalDate",
                "post.date.required");
        assertThat(error.getCode()).isEqualTo("post.date.required");
        assertThat(messageSource().getMessage(error, KOREAN))
                .isEqualTo("작성일을 입력하세요.");
    }

    @Test
    void fixedClockSeparatesTodayFromTomorrow() {
        var policy = new PostDatePolicy(FIXED_CLOCK);
        var today = LocalDate.of(2026, 3, 10);

        var accepted = new PostForm();
        accepted.setPublishedOn(today);
        var acceptedErrors = new BeanPropertyBindingResult(
                accepted, "postCreate");
        policy.validate(accepted, acceptedErrors);
        assertThat(acceptedErrors.hasErrors()).isFalse();

        var rejected = new PostForm();
        rejected.setPublishedOn(today.plusDays(1));
        var rejectedErrors = new BeanPropertyBindingResult(
                rejected, "postCreate");
        policy.validate(rejected, rejectedErrors);

        var error = rejectedErrors.getFieldError("publishedOn");
        assertThat(error).isNotNull();
        assertThat(error.getCodes()).containsExactly(
                "post.date.future.postCreate.publishedOn",
                "post.date.future.publishedOn",
                "post.date.future.java.time.LocalDate",
                "post.date.future");
        assertThat(messageSource().getMessage(error, KOREAN))
                .isEqualTo("작성일은 오늘 이후일 수 없습니다.");
    }

    private static BeanPropertyBindingResult bindingResult(
            String objectName) {
        return new BeanPropertyBindingResult(new PostForm(), objectName);
    }

    private static ResourceBundleMessageSource messageSource() {
        var source = new ResourceBundleMessageSource();
        source.setBasename("errorcodes/messages");
        source.setDefaultEncoding(StandardCharsets.UTF_8.name());
        return source;
    }
}