MVC 실패 경계 진단

package board.pipeline;

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

public record ReplacePostRequest(
        @NotBlank String title,
        @Size(min = 10, max = 500) String content) {
}

package board.pipeline;

public record PostResponse(
        long id,
        String title,
        String content,
        long version) {
}

package board.pipeline;

import java.util.concurrent.atomic.AtomicInteger;

public final class InvocationProbe {
    private final AtomicInteger controllerCalls = new AtomicInteger();
    private final AtomicInteger serviceCalls = new AtomicInteger();

    public void controllerEntered() {
        controllerCalls.incrementAndGet();
    }

    public void serviceEntered() {
        serviceCalls.incrementAndGet();
    }

    public Snapshot snapshot() {
        return new Snapshot(controllerCalls.get(), serviceCalls.get());
    }

    public void reset() {
        controllerCalls.set(0);
        serviceCalls.set(0);
    }

    public record Snapshot(int controllerCalls, int serviceCalls) {
    }
}

package board.pipeline;

public final class PostService {
    public static final String CURRENT_ETAG = "\"post-42-v7\"";

    private final InvocationProbe probe;

    public PostService(InvocationProbe probe) {
        this.probe = probe;
    }

    public PostResponse replace(
            long id,
            String ifMatch,
            ReplacePostRequest request) {
        probe.serviceEntered();

        if (id != 42L) {
            throw new PostNotFound(id);
        }
        if ("duplicate".equals(request.title())) {
            throw new DuplicateTitle(request.title());
        }
        if (!CURRENT_ETAG.equals(ifMatch)) {
            throw new StaleVersion(ifMatch, CURRENT_ETAG);
        }
        if ("explode".equals(request.title())) {
            throw new IllegalStateException("simulated unexpected service failure");
        }

        return new PostResponse(
                id,
                request.title(),
                request.content(),
                8L);
    }

    public static final class PostNotFound extends RuntimeException {
        public PostNotFound(long id) {
            super("post not found: " + id);
        }
    }

    public static final class DuplicateTitle extends RuntimeException {
        public DuplicateTitle(String title) {
            super("duplicate title: " + title);
        }
    }

    public static final class StaleVersion extends RuntimeException {
        public StaleVersion(String actual, String expected) {
            super("stale version: actual=" + actual + ", expected=" + expected);
        }
    }
}

package board.pipeline;

import jakarta.validation.Valid;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/pipeline/posts")
public final class PipelineController {
    private final InvocationProbe probe;
    private final PostService service;

    public PipelineController(
            InvocationProbe probe,
            PostService service) {
        this.probe = probe;
        this.service = service;
    }

    @PutMapping(
            path = "/{id}",
            consumes = MediaType.APPLICATION_JSON_VALUE,
            produces = MediaType.APPLICATION_JSON_VALUE)
    public PostResponse replace(
            @PathVariable long id,
            @RequestHeader(HttpHeaders.IF_MATCH) String ifMatch,
            @Valid @RequestBody ReplacePostRequest request) {
        probe.controllerEntered();
        return service.replace(id, ifMatch, request);
    }
}

package board.pipeline;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.UUID;
import org.springframework.web.filter.OncePerRequestFilter;

public final class RequestIdFilter extends OncePerRequestFilter {
    public static final String HEADER = "X-Request-Id";
    public static final String ATTRIBUTE =
            RequestIdFilter.class.getName() + ".requestId";

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain)
            throws ServletException, IOException {
        var requestId = UUID.randomUUID().toString();
        request.setAttribute(ATTRIBUTE, requestId);
        response.setHeader(HEADER, requestId);
        filterChain.doFilter(request, response);
    }
}

package board.pipeline;

import board.pipeline.PostService.DuplicateTitle;
import board.pipeline.PostService.PostNotFound;
import board.pipeline.PostService.StaleVersion;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(assignableTypes = PipelineController.class)
public final class PipelineExceptionHandler {
    @ExceptionHandler(PostNotFound.class)
    public ResponseEntity<ProblemDetail> missing(
            PostNotFound exception,
            HttpServletRequest request) {
        return problem(
                HttpStatus.NOT_FOUND,
                "POST_NOT_FOUND",
                "게시글을 찾을 수 없습니다.",
                request);
    }

    @ExceptionHandler(DuplicateTitle.class)
    public ResponseEntity<ProblemDetail> duplicate(
            DuplicateTitle exception,
            HttpServletRequest request) {
        return problem(
                HttpStatus.CONFLICT,
                "DUPLICATE_TITLE",
                "같은 제목의 게시글이 있습니다.",
                request);
    }

    @ExceptionHandler(StaleVersion.class)
    public ResponseEntity<ProblemDetail> stale(
            StaleVersion exception,
            HttpServletRequest request) {
        return problem(
                HttpStatus.PRECONDITION_FAILED,
                "STALE_VERSION",
                "읽은 뒤 게시글 버전이 변경됐습니다.",
                request);
    }

    @ExceptionHandler(IllegalStateException.class)
    public ResponseEntity<ProblemDetail> unexpected(
            IllegalStateException exception,
            HttpServletRequest request) {
        return problem(
                HttpStatus.INTERNAL_SERVER_ERROR,
                "INTERNAL_ERROR",
                "예상하지 못한 요청 처리 실패",
                request);
    }

    private static ResponseEntity<ProblemDetail> problem(
            HttpStatus status,
            String code,
            String detail,
            HttpServletRequest request) {
        var body = ProblemDetail.forStatusAndDetail(status, detail);
        body.setTitle(status.getReasonPhrase());
        body.setProperty("code", code);
        body.setProperty(
                "requestId",
                request.getAttribute(RequestIdFilter.ATTRIBUTE));
        return ResponseEntity.status(status).body(body);
    }
}

package board.pipeline;

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

@SpringBootConfiguration
@EnableAutoConfiguration
@Import({
        InvocationProbe.class,
        PipelineController.class,
        PipelineExceptionHandler.class,
        PostService.class,
        RequestIdFilter.class
})
public class PipelineTestApplication {
}

package board.pipeline;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_XML;
import static org.springframework.http.MediaType.TEXT_PLAIN;
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.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

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.test.web.servlet.MockMvc;

@SpringBootTest(
        classes = PipelineTestApplication.class,
        properties = "spring.web.resources.add-mappings=false")
@AutoConfigureMockMvc
class BeforeControllerFailureTest {
    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private InvocationProbe probe;

    @BeforeEach
    void resetProbe() {
        probe.reset();
    }

    @Test
    void unregisteredPathStopsAtMappingWith404() throws Exception {
        mockMvc.perform(put("/api/pipeline/missing/42")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .header(HttpHeaders.IF_MATCH, PostService.CURRENT_ETAG)
                        .content(validJson()))
                .andExpect(status().isNotFound())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    @Test
    void wrongMethodStopsAtMappingWith405() throws Exception {
        mockMvc.perform(post("/api/pipeline/posts/42")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .content(validJson()))
                .andExpect(status().isMethodNotAllowed())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    @Test
    void unacceptableRepresentationStopsWith406() throws Exception {
        mockMvc.perform(put("/api/pipeline/posts/42")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_XML)
                        .header(HttpHeaders.IF_MATCH, PostService.CURRENT_ETAG)
                        .content(validJson()))
                .andExpect(status().isNotAcceptable())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    @Test
    void unsupportedRequestMediaTypeStopsWith415() throws Exception {
        mockMvc.perform(put("/api/pipeline/posts/42")
                        .contentType(TEXT_PLAIN)
                        .accept(APPLICATION_JSON)
                        .header(HttpHeaders.IF_MATCH, PostService.CURRENT_ETAG)
                        .content("title=plain&content=not-json"))
                .andExpect(status().isUnsupportedMediaType())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    @Test
    void pathVariableConversionStopsWith400() throws Exception {
        mockMvc.perform(put("/api/pipeline/posts/not-a-number")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .header(HttpHeaders.IF_MATCH, PostService.CURRENT_ETAG)
                        .content(validJson()))
                .andExpect(status().isBadRequest())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    @Test
    void malformedJsonStopsAtRequestConverterWith400() throws Exception {
        mockMvc.perform(put("/api/pipeline/posts/42")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .header(HttpHeaders.IF_MATCH, PostService.CURRENT_ETAG)
                        .content("{broken"))
                .andExpect(status().isBadRequest())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    @Test
    void invalidDtoStopsAtValidationWith400() throws Exception {
        mockMvc.perform(put("/api/pipeline/posts/42")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .header(HttpHeaders.IF_MATCH, PostService.CURRENT_ETAG)
                        .content("{\"title\":\" \",\"content\":\"short\"}"))
                .andExpect(status().isBadRequest())
                .andExpect(header().exists(RequestIdFilter.HEADER));

        assertNoApplicationInvocation();
    }

    private void assertNoApplicationInvocation() {
        assertThat(probe.snapshot())
                .isEqualTo(new InvocationProbe.Snapshot(0, 0));
    }

    private static String validJson() {
        return "{\"title\":\"updated\","
                + "\"content\":\"ten characters or more\"}";
    }
}

package board.pipeline;

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.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 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;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;

@SpringBootTest(
        classes = PipelineTestApplication.class,
        properties = "spring.web.resources.add-mappings=false")
@AutoConfigureMockMvc
class AfterControllerFailureTest {
    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private InvocationProbe probe;

    @BeforeEach
    void resetProbe() {
        probe.reset();
    }

    @Test
    void missingResourceReachesServiceAndReturns404() throws Exception {
        mockMvc.perform(replace(404L, PostService.CURRENT_ETAG, "updated"))
                .andExpect(status().isNotFound())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(header().exists(RequestIdFilter.HEADER))
                .andExpect(jsonPath("$.code").value("POST_NOT_FOUND"));

        assertOneApplicationInvocation();
    }

    @Test
    void duplicateTitleReachesServiceAndReturns409() throws Exception {
        mockMvc.perform(replace(42L, PostService.CURRENT_ETAG, "duplicate"))
                .andExpect(status().isConflict())
                .andExpect(header().exists(RequestIdFilter.HEADER))
                .andExpect(jsonPath("$.code").value("DUPLICATE_TITLE"));

        assertOneApplicationInvocation();
    }

    @Test
    void staleIfMatchReachesServiceAndReturns412() throws Exception {
        mockMvc.perform(replace(42L, "\"post-42-v6\"", "updated"))
                .andExpect(status().isPreconditionFailed())
                .andExpect(header().exists(RequestIdFilter.HEADER))
                .andExpect(jsonPath("$.code").value("STALE_VERSION"));

        assertOneApplicationInvocation();
    }

    @Test
    void unexpectedServiceFailureReturnsGeneric500AndRequestId() throws Exception {
        var result = mockMvc.perform(
                        replace(42L, PostService.CURRENT_ETAG, "explode")
                                .header(
                                        RequestIdFilter.HEADER,
                                        "attacker-controlled"))
                .andExpect(status().isInternalServerError())
                .andExpect(header().exists(RequestIdFilter.HEADER))
                .andExpect(jsonPath("$.code").value("INTERNAL_ERROR"))
                .andExpect(jsonPath("$.requestId").isNotEmpty())
                .andExpect(jsonPath("$.detail")
                        .value("예상하지 못한 요청 처리 실패"))
                .andReturn();

        var response = result.getResponse();
        var requestId = response.getHeader(RequestIdFilter.HEADER);
        assertThat(requestId).isNotBlank();
        assertThat(requestId).isNotEqualTo("attacker-controlled");
        assertThat(response.getContentAsString())
                .contains("\"requestId\":\"" + requestId + "\"")
                .doesNotContain(
                        "attacker-controlled",
                        "IllegalStateException",
                        "simulated unexpected service failure",
                        "java.lang.",
                        "board.pipeline.PostService",
                        "stackTrace");

        assertOneApplicationInvocation();
    }

    private MockHttpServletRequestBuilder replace(
            long id,
            String ifMatch,
            String title) {
        var body = "{\"title\":\"" + title + "\","
                + "\"content\":\"ten characters or more\"}";
        return put("/api/pipeline/posts/{id}", id)
                .contentType(APPLICATION_JSON)
                .accept(APPLICATION_JSON)
                .header(HttpHeaders.IF_MATCH, ifMatch)
                .content(body);
    }

    private void assertOneApplicationInvocation() {
        assertThat(probe.snapshot())
                .isEqualTo(new InvocationProbe.Snapshot(1, 1));
    }
}