Bean 검증과 DTO

package board.validationdto;

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.PastOrPresent;
import jakarta.validation.constraints.Size;
import java.time.LocalDate;

public record CreatePostRequest(
        @NotBlank
        @Size(max = 80)
        String title,

        @NotBlank
        @Size(max = 720)
        String content,

        @NotNull
        @PastOrPresent
        LocalDate publishedOn) {

    public CreatePostCommand toCommand() {
        return new CreatePostCommand(
                title.strip(),
                content,
                publishedOn);
    }
}

package board.validationdto;

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;

public record UpdatePostRequest(
        @NotBlank
        @Size(max = 80)
        String title,

        @NotBlank
        @Size(max = 720)
        String content,

        @NotNull
        @Positive
        Long expectedVersion) {

    public UpdatePostCommand toCommand(long postId) {
        return new UpdatePostCommand(
                postId,
                title.strip(),
                content,
                expectedVersion);
    }
}

package board.validationdto;

import java.time.LocalDate;
import java.util.Objects;

public record CreatePostCommand(
        String title,
        String content,
        LocalDate publishedOn) {

    public CreatePostCommand {
        Objects.requireNonNull(title, "title");
        Objects.requireNonNull(content, "content");
        Objects.requireNonNull(publishedOn, "publishedOn");
    }
}

package board.validationdto;

import java.util.Objects;

public record UpdatePostCommand(
        long postId,
        String title,
        String content,
        long expectedVersion) {

    public UpdatePostCommand {
        if (postId <= 0) {
            throw new IllegalArgumentException("postId must be positive");
        }
        Objects.requireNonNull(title, "title");
        Objects.requireNonNull(content, "content");
        if (expectedVersion <= 0) {
            throw new IllegalArgumentException(
                    "expectedVersion must be positive");
        }
    }
}

package board.validationdto;

import java.util.Objects;

public record PostText(String title, String content) {
    public PostText {
        Objects.requireNonNull(title, "title");
        Objects.requireNonNull(content, "content");
        if (title.isBlank() || title.length() > 80) {
            throw new IllegalArgumentException("title is invalid");
        }
        if (content.isBlank() || content.length() > 720) {
            throw new IllegalArgumentException("content is invalid");
        }
    }
}

package board.validationdto;

import java.time.LocalDate;
import java.util.Objects;

public final class PostDraft {
    private final PostText text;
    private final LocalDate publishedOn;

    private PostDraft(PostText text, LocalDate publishedOn) {
        this.text = Objects.requireNonNull(text, "text");
        this.publishedOn = Objects.requireNonNull(
                publishedOn, "publishedOn");
    }

    public static PostDraft create(
            String title,
            String content,
            LocalDate publishedOn,
            LocalDate today) {
        Objects.requireNonNull(publishedOn, "publishedOn");
        Objects.requireNonNull(today, "today");
        if (publishedOn.isAfter(today)) {
            throw new IllegalArgumentException(
                    "publishedOn must not be in the future");
        }
        return new PostDraft(
                new PostText(title, content),
                publishedOn);
    }

    public PostText text() {
        return text;
    }

    public LocalDate publishedOn() {
        return publishedOn;
    }
}

package board.validationdto;

public interface PostStore {
    long insert(PostDraft draft);

    void replace(
            long postId,
            PostText text,
            long expectedVersion);
}

package board.validationdto;

public interface PostApplicationService {
    long register(CreatePostCommand command);

    void revise(UpdatePostCommand command);
}

package board.validationdto;

import java.time.Clock;
import java.time.LocalDate;
import java.util.Objects;

public final class DefaultPostApplicationService
        implements PostApplicationService {
    private final PostStore store;
    private final Clock clock;

    public DefaultPostApplicationService(
            PostStore store,
            Clock clock) {
        this.store = Objects.requireNonNull(store, "store");
        this.clock = Objects.requireNonNull(clock, "clock");
    }

    @Override
    public long register(CreatePostCommand command) {
        Objects.requireNonNull(command, "command");
        var draft = PostDraft.create(
                command.title(),
                command.content(),
                command.publishedOn(),
                LocalDate.now(clock));
        return store.insert(draft);
    }

    @Override
    public void revise(UpdatePostCommand command) {
        Objects.requireNonNull(command, "command");
        var text = new PostText(
                command.title(),
                command.content());
        store.replace(
                command.postId(),
                text,
                command.expectedVersion());
    }
}

package board.validationdto;

import org.springframework.boot.jackson.autoconfigure.JsonMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import tools.jackson.databind.DeserializationFeature;

@Configuration(proxyBeanMethods = false)
public final class ValidationJsonConfiguration {
    @Bean
    JsonMapperBuilderCustomizer rejectUnknownRequestFields() {
        return builder -> builder.enable(
                DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    }
}

package board.validationdto;

public final class InvalidPostIdException extends RuntimeException {
    public InvalidPostIdException() {
        super("postId must be positive");
    }
}

package board.validationdto;

import jakarta.validation.Valid;
import java.net.URI;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/b88/validation-posts")
public final class ValidationPostController {
    private final PostApplicationService service;

    public ValidationPostController(PostApplicationService service) {
        this.service = service;
    }

    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Void> create(
            @Valid @RequestBody CreatePostRequest request) {
        var postId = service.register(request.toCommand());
        return ResponseEntity
                .created(URI.create(
                        "/api/b88/validation-posts/" + postId))
                .build();
    }

    @PutMapping(
            path = "/{postId}",
            consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Void> replace(
            @PathVariable long postId,
            @Valid @RequestBody UpdatePostRequest request) {
        if (postId <= 0) {
            throw new InvalidPostIdException();
        }
        service.revise(request.toCommand(postId));
        return ResponseEntity.noContent().build();
    }
}

package board.validationdto;

public record FieldViolation(String field, String code) {
}

package board.validationdto;

import java.util.Objects;
import org.springframework.validation.FieldError;

public final class ApiFieldCodePolicy {
    private ApiFieldCodePolicy() {
    }

    public static String externalCode(FieldError error) {
        Objects.requireNonNull(error, "error");
        var internalCode = Objects.requireNonNullElse(
                error.getCode(), "Invalid");
        return switch (error.getField()) {
            case "title" -> switch (internalCode) {
                case "NotBlank" -> "post.title.required";
                case "Size" -> "post.title.length";
                default -> "post.title.invalid";
            };
            case "content" -> switch (internalCode) {
                case "NotBlank" -> "post.content.required";
                case "Size" -> "post.content.length";
                default -> "post.content.invalid";
            };
            case "publishedOn" -> switch (internalCode) {
                case "NotNull" -> "post.published-on.required";
                case "PastOrPresent" -> "post.published-on.future";
                default -> "post.published-on.invalid";
            };
            case "expectedVersion" -> switch (internalCode) {
                case "NotNull" -> "post.version.required";
                case "Positive" -> "post.version.positive";
                default -> "post.version.invalid";
            };
            default -> "request.field.invalid";
        };
    }
}

package board.validationdto;

import java.net.URI;
import java.util.Comparator;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(assignableTypes = ValidationPostController.class)
public final class ValidationProblemHandler {
    @ExceptionHandler(InvalidPostIdException.class)
    public ResponseEntity<ProblemDetail> invalidPostId() {
        var problem = ProblemDetail.forStatusAndDetail(
                HttpStatus.BAD_REQUEST,
                "게시글 ID는 양수여야 합니다.");
        problem.setType(URI.create(
                "https://andongmin.com/problems/request-path"));
        problem.setTitle("요청 경로 검증 실패");
        problem.setProperty("code", "request.path.invalid");
        problem.setProperty("fields", List.of(
                new FieldViolation("postId", "post.id.positive")));
        return ResponseEntity.badRequest().body(problem);
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ProblemDetail> invalidFields(
            MethodArgumentNotValidException failure) {
        var fields = failure.getBindingResult()
                .getFieldErrors()
                .stream()
                .map(error -> new FieldViolation(
                        error.getField(),
                        ApiFieldCodePolicy.externalCode(error)))
                .sorted(Comparator
                        .comparing(FieldViolation::field)
                        .thenComparing(FieldViolation::code))
                .toList();

        var problem = ProblemDetail.forStatusAndDetail(
                HttpStatus.BAD_REQUEST,
                "요청 필드의 형식과 범위를 확인하세요.");
        problem.setType(URI.create(
                "https://andongmin.com/problems/request-validation"));
        problem.setTitle("요청 검증 실패");
        problem.setProperty("code", "request.validation.failed");
        problem.setProperty("fields", fields);
        return ResponseEntity.badRequest().body(problem);
    }

    @ExceptionHandler(HttpMessageNotReadableException.class)
    public ResponseEntity<ProblemDetail> unreadableJson(
            HttpMessageNotReadableException failure) {
        var problem = ProblemDetail.forStatusAndDetail(
                HttpStatus.BAD_REQUEST,
                "JSON 본문을 읽을 수 없습니다.");
        problem.setType(URI.create(
                "https://andongmin.com/problems/request-json"));
        problem.setTitle("요청 본문 읽기 실패");
        problem.setProperty("code", "request.json.unreadable");
        return ResponseEntity.badRequest().body(problem);
    }
}

package board.validationdto;

import java.util.ArrayList;
import java.util.List;

public final class RecordingPostApplicationService
        implements PostApplicationService {
    private final List<Object> commands = new ArrayList<>();

    @Override
    public long register(CreatePostCommand command) {
        commands.add(command);
        return 41L;
    }

    @Override
    public void revise(UpdatePostCommand command) {
        commands.add(command);
    }

    public List<Object> commands() {
        return List.copyOf(commands);
    }

    public void reset() {
        commands.clear();
    }
}

package board.validationdto;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;

@SpringBootConfiguration(proxyBeanMethods = false)
@EnableAutoConfiguration
@Import({
        ValidationJsonConfiguration.class,
        ValidationPostController.class,
        ValidationProblemHandler.class
})
public class ValidationDtoTestApplication {
    @Bean
    RecordingPostApplicationService postApplicationService() {
        return new RecordingPostApplicationService();
    }
}

package board.validationdto;

import static org.assertj.core.api.Assertions.assertThat;
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.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import java.time.LocalDate;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest(classes = ValidationDtoTestApplication.class)
@AutoConfigureMockMvc
class ValidationApiContractTest {
    private static final String ROUTE =
            "/api/b88/validation-posts";

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private RecordingPostApplicationService service;

    @BeforeEach
    void resetService() {
        service.reset();
    }

    @Test
    void validCreateJsonMapsExactlyOneCreateCommand() throws Exception {
        mockMvc.perform(post(ROUTE)
                        .contentType(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": "  Bean Validation  ",
                                  "content": "DTO boundary",
                                  "publishedOn": "2000-01-01"
                                }
                                """))
                .andExpect(status().isCreated())
                .andExpect(header().string(
                        HttpHeaders.LOCATION,
                        ROUTE + "/41"));

        assertThat(service.commands()).containsExactly(
                new CreatePostCommand(
                        "Bean Validation",
                        "DTO boundary",
                        LocalDate.of(2000, 1, 1)));
    }

    @Test
    void invalidCreateFieldsReturnStableSortedCodesAndSkipService()
            throws Exception {
        mockMvc.perform(post(ROUTE)
                        .contentType(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": " ",
                                  "content": "",
                                  "publishedOn": "2999-01-01"
                                }
                                """))
                .andExpect(status().isBadRequest())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(jsonPath("$.type").value(
                        "https://andongmin.com/problems/request-validation"))
                .andExpect(jsonPath("$.code").value(
                        "request.validation.failed"))
                .andExpect(jsonPath("$.fields.length()").value(3))
                .andExpect(jsonPath("$.fields[0].field").value("content"))
                .andExpect(jsonPath("$.fields[0].code").value(
                        "post.content.required"))
                .andExpect(jsonPath("$.fields[1].field").value(
                        "publishedOn"))
                .andExpect(jsonPath("$.fields[1].code").value(
                        "post.published-on.future"))
                .andExpect(jsonPath("$.fields[2].field").value("title"))
                .andExpect(jsonPath("$.fields[2].code").value(
                        "post.title.required"))
                .andExpect(jsonPath("$.fields[0].rejectedValue")
                        .doesNotExist());

        assertThat(service.commands()).isEmpty();
    }

    @Test
    void malformedJsonAndInvalidDateFailBeforeBeanValidation()
            throws Exception {
        expectUnreadable("{\"title\":\"broken\"");
        expectUnreadable("""
                {
                  "title": "date",
                  "content": "invalid date",
                  "publishedOn": "not-a-date"
                }
                """);

        assertThat(service.commands()).isEmpty();
    }

    @Test
    void createAndUpdateRejectEachOthersFields() throws Exception {
        expectUnreadable("""
                {
                  "title": "create",
                  "content": "wrong shape",
                  "publishedOn": "2000-01-01",
                  "expectedVersion": 3
                }
                """);

        mockMvc.perform(put(ROUTE + "/41")
                        .contentType(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": "update",
                                  "content": "wrong shape",
                                  "expectedVersion": 3,
                                  "publishedOn": "2000-01-01"
                                }
                                """))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.code").value(
                        "request.json.unreadable"));

        assertThat(service.commands()).isEmpty();
    }

    @Test
    void validUpdateMapsVersionedCommandWithoutPublishedDate()
            throws Exception {
        mockMvc.perform(put(ROUTE + "/41")
                        .contentType(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": "  revised  ",
                                  "content": "replacement body",
                                  "expectedVersion": 3
                                }
                                """))
                .andExpect(status().isNoContent());

        assertThat(service.commands()).containsExactly(
                new UpdatePostCommand(
                        41L,
                        "revised",
                        "replacement body",
                        3L));
    }

    @Test
    void nonPositiveUpdateIdReturnsStablePathProblemAndSkipsService()
            throws Exception {
        mockMvc.perform(put(ROUTE + "/0")
                        .contentType(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": "revised",
                                  "content": "replacement body",
                                  "expectedVersion": 3
                                }
                                """))
                .andExpect(status().isBadRequest())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(jsonPath("$.type").value(
                        "https://andongmin.com/problems/request-path"))
                .andExpect(jsonPath("$.status").value(400))
                .andExpect(jsonPath("$.code").value(
                        "request.path.invalid"))
                .andExpect(jsonPath("$.fields.length()").value(1))
                .andExpect(jsonPath("$.fields[0].field").value("postId"))
                .andExpect(jsonPath("$.fields[0].code").value(
                        "post.id.positive"))
                .andExpect(jsonPath("$.fields[0].rejectedValue")
                        .doesNotExist());

        assertThat(service.commands()).isEmpty();
    }

    @Test
    void missingUpdateVersionUsesTheVersionFieldCodeContract()
            throws Exception {
        mockMvc.perform(put(ROUTE + "/41")
                        .contentType(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": "revised",
                                  "content": "replacement body"
                                }
                                """))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.code").value(
                        "request.validation.failed"))
                .andExpect(jsonPath("$.fields.length()").value(1))
                .andExpect(jsonPath("$.fields[0].field").value(
                        "expectedVersion"))
                .andExpect(jsonPath("$.fields[0].code").value(
                        "post.version.required"));

        assertThat(service.commands()).isEmpty();
    }

    private void expectUnreadable(String body) throws Exception {
        mockMvc.perform(post(ROUTE)
                        .contentType(APPLICATION_JSON)
                        .content(body))
                .andExpect(status().isBadRequest())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(jsonPath("$.type").value(
                        "https://andongmin.com/problems/request-json"))
                .andExpect(jsonPath("$.code").value(
                        "request.json.unreadable"))
                .andExpect(jsonPath("$.fields").doesNotExist());
    }
}

package board.validationdto;

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

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import org.junit.jupiter.api.Test;

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

    @Test
    void futureCreateCommandIsRejectedBeforeStoreInsert() {
        var store = new RecordingPostStore();
        var service = new DefaultPostApplicationService(
                store, FIXED_CLOCK);

        assertThatThrownBy(() -> service.register(
                new CreatePostCommand(
                        "future",
                        "bypassed HTTP validation",
                        LocalDate.of(2026, 3, 11))))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("publishedOn must not be in the future");

        assertThat(store.inserted).isNull();
        assertThat(store.replacement).isNull();
    }

    @Test
    void blankUpdateCommandIsRejectedBeforeStoreReplace() {
        var store = new RecordingPostStore();
        var service = new DefaultPostApplicationService(
                store, FIXED_CLOCK);

        assertThatThrownBy(() -> service.revise(
                new UpdatePostCommand(
                        41L,
                        " ",
                        "bypassed HTTP validation",
                        3L)))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("title is invalid");

        assertThat(store.inserted).isNull();
        assertThat(store.replacement).isNull();
    }

    @Test
    void todayAndVersionedReplacementCrossTheStoreBoundaryOnce() {
        var store = new RecordingPostStore();
        var service = new DefaultPostApplicationService(
                store, FIXED_CLOCK);

        var postId = service.register(new CreatePostCommand(
                "today",
                "valid domain state",
                LocalDate.of(2026, 3, 10)));
        service.revise(new UpdatePostCommand(
                postId,
                "revised",
                "replacement body",
                3L));

        assertThat(postId).isEqualTo(41L);
        assertThat(store.inserted).isNotNull();
        assertThat(store.inserted.text()).isEqualTo(
                new PostText("today", "valid domain state"));
        assertThat(store.inserted.publishedOn()).isEqualTo(
                LocalDate.of(2026, 3, 10));
        assertThat(store.replacement).isEqualTo(new Replacement(
                41L,
                new PostText("revised", "replacement body"),
                3L));
    }

    private static final class RecordingPostStore implements PostStore {
        private PostDraft inserted;
        private Replacement replacement;

        @Override
        public long insert(PostDraft draft) {
            if (inserted != null) {
                throw new AssertionError("insert called more than once");
            }
            inserted = draft;
            return 41L;
        }

        @Override
        public void replace(
                long postId,
                PostText text,
                long expectedVersion) {
            if (replacement != null) {
                throw new AssertionError("replace called more than once");
            }
            replacement = new Replacement(
                    postId, text, expectedVersion);
        }
    }

    private record Replacement(
            long postId,
            PostText text,
            long expectedVersion) {
    }
}