디스패처 서블릿 구조

package board.mvc;

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

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.Test;
import org.springframework.core.ResolvableType;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ProblemDetail;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.json
        .JacksonJsonHttpMessageConverter;
import org.springframework.stereotype.Controller;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation
        .MethodArgumentTypeMismatchException;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;

class DispatcherServletBoundaryTest {
    private static final String POST_DETAIL = "post-detail";

    @Test
    void viewSuccessRunsInterceptorsAndFixedViewInExactOrder()
            throws Exception {
        var fixture = fixture();
        var expectedPage =
                new PostPageModel(42L, "Dispatcher boundary");

        fixture.mvc()
                .perform(get("/mvc/posts/42"))
                .andExpect(status().isOk())
                .andExpect(view().name(POST_DETAIL))
                .andExpect(model().attribute(
                        "post", expectedPage))
                .andExpect(content().string(
                        "post-detail:42"));

        assertThat(fixture.ledger().snapshot())
                .containsExactly(
                        "outer.pre:true",
                        "inner.pre:true",
                        "controller.view",
                        "inner.post:model-view",
                        "outer.post:model-view",
                        "view.resolve:post-detail",
                        "view.render",
                        "inner.after:null",
                        "outer.after:null");
        assertThat(fixture.counters().viewCalls()).isOne();
        assertThat(fixture.counters().totalCalls()).isOne();
        assertThat(fixture.views().lookupCalls()).isOne();
        assertThat(fixture.views().lastLogicalName())
                .isEqualTo(POST_DETAIL);
        assertThat(fixture.view().renderCalls()).isOne();
        assertThat(fixture.view().lastPage())
                .isExactlyInstanceOf(PostPageModel.class)
                .isEqualTo(expectedPage);
        assertThat(fixture.converter().successfulWrites()).isZero();
    }

    @Test
    void responseBodyUsesConverterAndSkipsViewResolver()
            throws Exception {
        var fixture = fixture();

        fixture.mvc()
                .perform(get("/mvc/body")
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.id").value(42))
                .andExpect(jsonPath("$.status").value("ok"));

        assertThat(fixture.ledger().snapshot())
                .containsExactly(
                        "outer.pre:true",
                        "inner.pre:true",
                        "controller.body",
                        "converter.write",
                        "inner.post:null",
                        "outer.post:null",
                        "inner.after:null",
                        "outer.after:null");
        assertThat(fixture.counters().bodyCalls()).isOne();
        assertThat(fixture.counters().totalCalls()).isOne();
        assertThat(fixture.converter().successfulWrites()).isOne();
        assertThat(fixture.views().lookupCalls()).isZero();
        assertThat(fixture.view().renderCalls()).isZero();
        assertThat(fixture.outer().nullModelAndViewPostCalls())
                .isOne();
        assertThat(fixture.inner().nullModelAndViewPostCalls())
                .isOne();
    }

    @Test
    void secondPreHandleFalseCompletesOnlyEnteredOuterInterceptor()
            throws Exception {
        var fixture = fixture();

        fixture.mvc()
                .perform(get("/mvc/blocked"))
                .andReturn();

        assertThat(fixture.ledger().snapshot())
                .containsExactly(
                        "outer.pre:true",
                        "inner.pre:false",
                        "outer.after:null");
        assertThat(fixture.counters().totalCalls()).isZero();
        assertThat(fixture.outer().preCalls()).isOne();
        assertThat(fixture.inner().preCalls()).isOne();
        assertThat(fixture.outer().postCalls()).isZero();
        assertThat(fixture.inner().postCalls()).isZero();
        assertThat(fixture.outer().afterCalls()).isOne();
        assertThat(fixture.inner().afterCalls()).isZero();
        assertThat(fixture.views().lookupCalls()).isZero();
        assertThat(fixture.view().renderCalls()).isZero();
        assertThat(fixture.converter().successfulWrites()).isZero();
    }

    @Test
    void resolvedControllerExceptionSkipsPostHandleAndCompletesWithNullFailure()
            throws Exception {
        var fixture = fixture();

        fixture.mvc()
                .perform(get("/mvc/failure")
                        .accept(MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(status().isConflict())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(jsonPath("$.status").value(409))
                .andExpect(jsonPath("$.code")
                        .value("POST_DUPLICATE"));

        assertThat(fixture.ledger().snapshot())
                .containsExactly(
                        "outer.pre:true",
                        "inner.pre:true",
                        "controller.failure",
                        "advice.duplicate",
                        "converter.write",
                        "inner.after:null",
                        "outer.after:null");
        assertThat(fixture.counters().failureCalls()).isOne();
        assertThat(fixture.counters().adviceCalls()).isOne();
        assertThat(fixture.outer().postCalls()).isZero();
        assertThat(fixture.inner().postCalls()).isZero();
        assertThat(fixture.outer().afterCalls()).isOne();
        assertThat(fixture.inner().afterCalls()).isOne();
        assertThat(fixture.outer().lastCompletionFailure()).isNull();
        assertThat(fixture.inner().lastCompletionFailure()).isNull();
        assertThat(fixture.views().lookupCalls()).isZero();
        assertThat(fixture.view().renderCalls()).isZero();
        assertThat(fixture.converter().successfulWrites()).isOne();
    }

    @Test
    void argumentConversionFailureReturns400BeforeController()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc()
                .perform(get("/mvc/convert/not-a-number"))
                .andExpect(status().isBadRequest())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(
                        MethodArgumentTypeMismatchException.class);
        assertThat(fixture.ledger().snapshot())
                .containsExactly(
                        "outer.pre:true",
                        "inner.pre:true",
                        "inner.after:null",
                        "outer.after:null");
        assertThat(fixture.counters().totalCalls()).isZero();
        assertThat(fixture.outer().preCalls()).isOne();
        assertThat(fixture.inner().preCalls()).isOne();
        assertThat(fixture.outer().postCalls()).isZero();
        assertThat(fixture.inner().postCalls()).isZero();
        assertThat(fixture.outer().afterCalls()).isOne();
        assertThat(fixture.inner().afterCalls()).isOne();
        assertThat(fixture.outer().lastCompletionFailure()).isNull();
        assertThat(fixture.inner().lastCompletionFailure()).isNull();
        assertThat(fixture.views().lookupCalls()).isZero();
        assertThat(fixture.view().renderCalls()).isZero();
        assertThat(fixture.converter().successfulWrites()).isZero();
    }

    @Test
    void methodMismatchReturns405WithAllowBeforeInterceptors()
            throws Exception {
        var fixture = fixture();

        fixture.mvc()
                .perform(post("/mvc/method"))
                .andExpect(status().isMethodNotAllowed())
                .andExpect(header().string(
                        HttpHeaders.ALLOW, "GET"));

        assertThat(fixture.ledger().snapshot()).isEmpty();
        assertThat(fixture.outer().preCalls()).isZero();
        assertThat(fixture.inner().preCalls()).isZero();
        assertThat(fixture.counters().totalCalls()).isZero();
        assertThat(fixture.views().lookupCalls()).isZero();
        assertThat(fixture.view().renderCalls()).isZero();
        assertThat(fixture.converter().successfulWrites()).isZero();
    }

    @Test
    void missingHandlerReturns404WithoutDownstreamCalls()
            throws Exception {
        var fixture = fixture();

        fixture.mvc()
                .perform(get("/mvc/missing"))
                .andExpect(status().isNotFound());

        assertThat(fixture.ledger().snapshot()).isEmpty();
        assertThat(fixture.outer().preCalls()).isZero();
        assertThat(fixture.inner().preCalls()).isZero();
        assertThat(fixture.counters().totalCalls()).isZero();
        assertThat(fixture.counters().adviceCalls()).isZero();
        assertThat(fixture.views().lookupCalls()).isZero();
        assertThat(fixture.view().renderCalls()).isZero();
        assertThat(fixture.converter().successfulWrites()).isZero();
    }

    private static SpringFixture fixture() {
        var ledger = new EventLedger();
        var counters = new ControllerCounters();
        var view = new FixedTestView(ledger);
        var views = ExactViewRegistry.postDetailOnly(
                ledger, view);
        var converter = new RecordingJacksonConverter(
                ledger);
        var outer = new RecordingInterceptor(
                "outer", ledger, null);
        var inner = new RecordingInterceptor(
                "inner", ledger, "/mvc/blocked");
        var controller = new BoundaryController(
                ledger, counters);
        var advice = new BoundaryAdvice(
                ledger, counters);

        MockMvc mvc = MockMvcBuilders
                .standaloneSetup(controller)
                .setControllerAdvice(advice)
                .addInterceptors(outer, inner)
                .setViewResolvers(views)
                .setMessageConverters(converter)
                .build();

        return new SpringFixture(
                mvc,
                ledger,
                counters,
                outer,
                inner,
                views,
                view,
                converter);
    }

    record SpringFixture(
            MockMvc mvc,
            EventLedger ledger,
            ControllerCounters counters,
            RecordingInterceptor outer,
            RecordingInterceptor inner,
            ExactViewRegistry views,
            FixedTestView view,
            RecordingJacksonConverter converter) {}

    record PostPageModel(long id, String title) {
        PostPageModel {
            if (id <= 0) {
                throw new IllegalArgumentException(
                        "id must be positive");
            }
            title = Objects.requireNonNull(title, "title");
        }
    }

    record PostResponse(long id, String status) {
        PostResponse {
            if (id <= 0) {
                throw new IllegalArgumentException(
                        "id must be positive");
            }
            status = Objects.requireNonNull(status, "status");
        }
    }

    @Controller
    @RequestMapping("/mvc")
    static final class BoundaryController {
        private final EventLedger ledger;
        private final ControllerCounters counters;

        BoundaryController(
                EventLedger ledger,
                ControllerCounters counters) {
            this.ledger = Objects.requireNonNull(
                    ledger, "ledger");
            this.counters = Objects.requireNonNull(
                    counters, "counters");
        }

        @GetMapping("/posts/{id}")
        String view(
                @PathVariable("id") long id,
                Model model) {
            counters.recordView();
            ledger.add("controller.view");
            model.addAttribute(
                    "post",
                    new PostPageModel(
                            id, "Dispatcher boundary"));
            return POST_DETAIL;
        }

        @ResponseBody
        @GetMapping(
                value = "/body",
                produces = MediaType.APPLICATION_JSON_VALUE)
        PostResponse body() {
            counters.recordBody();
            ledger.add("controller.body");
            return new PostResponse(42L, "ok");
        }

        @GetMapping("/blocked")
        String blocked() {
            counters.recordBlocked();
            ledger.add("controller.blocked");
            return POST_DETAIL;
        }

        @GetMapping("/failure")
        String failure() {
            counters.recordFailure();
            ledger.add("controller.failure");
            throw new DuplicatePostException(
                    "A post already exists for that day");
        }

        @ResponseBody
        @GetMapping(
                value = "/convert/{id}",
                produces = MediaType.APPLICATION_JSON_VALUE)
        PostResponse convert(
                @PathVariable("id") long id) {
            counters.recordConversion();
            ledger.add("controller.convert");
            return new PostResponse(id, "converted");
        }

        @ResponseBody
        @GetMapping(
                value = "/method",
                produces = MediaType.APPLICATION_JSON_VALUE)
        PostResponse method() {
            counters.recordMethod();
            ledger.add("controller.method");
            return new PostResponse(42L, "method");
        }
    }

    @RestControllerAdvice
    static final class BoundaryAdvice {
        private final EventLedger ledger;
        private final ControllerCounters counters;

        BoundaryAdvice(
                EventLedger ledger,
                ControllerCounters counters) {
            this.ledger = Objects.requireNonNull(
                    ledger, "ledger");
            this.counters = Objects.requireNonNull(
                    counters, "counters");
        }

        @ExceptionHandler(DuplicatePostException.class)
        ResponseEntity<ProblemDetail> duplicate(
                DuplicatePostException failure) {
            Objects.requireNonNull(failure, "failure");
            counters.recordAdvice();
            ledger.add("advice.duplicate");

            var problem = ProblemDetail.forStatusAndDetail(
                    HttpStatus.CONFLICT,
                    "A post already exists for that day");
            problem.setTitle("Duplicate post");
            problem.setProperty(
                    "code", "POST_DUPLICATE");

            return ResponseEntity
                    .status(HttpStatus.CONFLICT)
                    .contentType(
                            MediaType.APPLICATION_PROBLEM_JSON)
                    .body(problem);
        }
    }

    static final class RecordingInterceptor
            implements HandlerInterceptor {
        private final String name;
        private final EventLedger ledger;
        private final String rejectedPath;
        private final AtomicInteger preCalls =
                new AtomicInteger();
        private final AtomicInteger postCalls =
                new AtomicInteger();
        private final AtomicInteger nullModelAndViewPostCalls =
                new AtomicInteger();
        private final AtomicInteger afterCalls =
                new AtomicInteger();
        private Exception lastCompletionFailure;

        RecordingInterceptor(
                String name,
                EventLedger ledger,
                String rejectedPath) {
            this.name = Objects.requireNonNull(name, "name");
            this.ledger = Objects.requireNonNull(
                    ledger, "ledger");
            this.rejectedPath = rejectedPath;
        }

        @Override
        public boolean preHandle(
                HttpServletRequest request,
                HttpServletResponse response,
                Object handler) {
            preCalls.incrementAndGet();
            var admitted = rejectedPath == null
                    || !rejectedPath.equals(
                            request.getRequestURI());
            ledger.add(
                    name + ".pre:" + admitted);
            return admitted;
        }

        @Override
        public void postHandle(
                HttpServletRequest request,
                HttpServletResponse response,
                Object handler,
                ModelAndView modelAndView) {
            postCalls.incrementAndGet();
            var shape = modelAndView == null
                    ? "null"
                    : "model-view";
            if (modelAndView == null) {
                nullModelAndViewPostCalls.incrementAndGet();
            }
            ledger.add(name + ".post:" + shape);
        }

        @Override
        public void afterCompletion(
                HttpServletRequest request,
                HttpServletResponse response,
                Object handler,
                Exception failure) {
            afterCalls.incrementAndGet();
            lastCompletionFailure = failure;
            ledger.add(
                    name
                            + ".after:"
                            + (failure == null
                                    ? "null"
                                    : failure
                                            .getClass()
                                            .getSimpleName()));
        }

        int preCalls() {
            return preCalls.get();
        }

        int postCalls() {
            return postCalls.get();
        }

        int nullModelAndViewPostCalls() {
            return nullModelAndViewPostCalls.get();
        }

        int afterCalls() {
            return afterCalls.get();
        }

        Exception lastCompletionFailure() {
            return lastCompletionFailure;
        }
    }

    static final class RecordingJacksonConverter
            extends JacksonJsonHttpMessageConverter {
        private final EventLedger ledger;
        private final AtomicInteger successfulWrites =
                new AtomicInteger();

        RecordingJacksonConverter(EventLedger ledger) {
            this.ledger = Objects.requireNonNull(
                    ledger, "ledger");
        }

        @Override
        protected void writeInternal(
                Object value,
                ResolvableType type,
                HttpOutputMessage output,
                Map<String, Object> hints)
                throws IOException,
                        HttpMessageNotWritableException {
            super.writeInternal(
                    value, type, output, hints);
            successfulWrites.incrementAndGet();
            ledger.add("converter.write");
        }

        int successfulWrites() {
            return successfulWrites.get();
        }
    }

    static final class ExactViewRegistry
            implements ViewResolver {
        private final EventLedger ledger;
        private final View fixedView;
        private final AtomicInteger lookupCalls =
                new AtomicInteger();
        private String lastLogicalName;

        private ExactViewRegistry(
                EventLedger ledger,
                View fixedView) {
            this.ledger = Objects.requireNonNull(
                    ledger, "ledger");
            this.fixedView = Objects.requireNonNull(
                    fixedView, "fixedView");
        }

        static ExactViewRegistry postDetailOnly(
                EventLedger ledger,
                View fixedView) {
            return new ExactViewRegistry(
                    ledger, fixedView);
        }

        @Override
        public View resolveViewName(
                String viewName,
                Locale locale) {
            Objects.requireNonNull(locale, "locale");
            lookupCalls.incrementAndGet();
            lastLogicalName = viewName;
            ledger.add("view.resolve:" + viewName);
            if (!POST_DETAIL.equals(viewName)) {
                throw new IllegalArgumentException(
                        "Unknown logical view: " + viewName);
            }
            return fixedView;
        }

        int lookupCalls() {
            return lookupCalls.get();
        }

        String lastLogicalName() {
            return lastLogicalName;
        }
    }

    static final class FixedTestView implements View {
        private final EventLedger ledger;
        private final AtomicInteger renderCalls =
                new AtomicInteger();
        private PostPageModel lastPage;

        FixedTestView(EventLedger ledger) {
            this.ledger = Objects.requireNonNull(
                    ledger, "ledger");
        }

        @Override
        public void render(
                Map<String, ?> model,
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            renderCalls.incrementAndGet();
            ledger.add("view.render");
            var value = model.get("post");
            if (!(value instanceof PostPageModel page)) {
                throw new IllegalArgumentException(
                        "post must be PostPageModel");
            }
            lastPage = page;
            response.setContentType(
                    MediaType.TEXT_PLAIN_VALUE);
            response.getWriter().write(
                    POST_DETAIL + ":" + page.id());
        }

        int renderCalls() {
            return renderCalls.get();
        }

        PostPageModel lastPage() {
            return lastPage;
        }
    }

    static final class ControllerCounters {
        private final AtomicInteger total =
                new AtomicInteger();
        private final AtomicInteger view =
                new AtomicInteger();
        private final AtomicInteger body =
                new AtomicInteger();
        private final AtomicInteger blocked =
                new AtomicInteger();
        private final AtomicInteger failure =
                new AtomicInteger();
        private final AtomicInteger conversion =
                new AtomicInteger();
        private final AtomicInteger method =
                new AtomicInteger();
        private final AtomicInteger advice =
                new AtomicInteger();

        void recordView() {
            total.incrementAndGet();
            view.incrementAndGet();
        }

        void recordBody() {
            total.incrementAndGet();
            body.incrementAndGet();
        }

        void recordBlocked() {
            total.incrementAndGet();
            blocked.incrementAndGet();
        }

        void recordFailure() {
            total.incrementAndGet();
            failure.incrementAndGet();
        }

        void recordConversion() {
            total.incrementAndGet();
            conversion.incrementAndGet();
        }

        void recordMethod() {
            total.incrementAndGet();
            method.incrementAndGet();
        }

        void recordAdvice() {
            advice.incrementAndGet();
        }

        int totalCalls() {
            return total.get();
        }

        int viewCalls() {
            return view.get();
        }

        int bodyCalls() {
            return body.get();
        }

        int failureCalls() {
            return failure.get();
        }

        int adviceCalls() {
            return advice.get();
        }
    }

    static final class EventLedger {
        private final List<String> events =
                new ArrayList<>();

        void add(String event) {
            events.add(
                    Objects.requireNonNull(
                            event, "event"));
        }

        List<String> snapshot() {
            return List.copyOf(events);
        }
    }

    static final class DuplicatePostException
            extends RuntimeException {
        DuplicatePostException(String message) {
            super(message);
        }
    }
}