프런트 컨트롤러 발전

package board.mvc;

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

import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.catalina.startup.Tomcat;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

class EmbeddedFrontControllerRoutingBoundaryTest {
    @TempDir
    Path tomcatBase;

    @Test
    void methodTokensAreCaseSensitive() {
        assertThat(RouteKey.parse("GET", "/posts/%2Fdetail"))
                .isEqualTo(new RouteKey(
                        RouteMethod.GET, "/posts/%2Fdetail"));

        assertThatThrownBy(() ->
                RouteKey.parse("get", "/posts/%2Fdetail"))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessageContaining("unsupported method token");
        assertThatThrownBy(() ->
                RouteKey.parse("Get", "/posts/%2Fdetail"))
                .isInstanceOf(IllegalArgumentException.class);
    }

    @Test
    void duplicateRegistrationsFailBeforeServing() {
        PageController controller = () -> new ModelView(
                "post-detail", new PageModel(42L, "등록 확인"));
        var duplicate = new Route(
                RouteKey.parse("GET", "/posts/detail"),
                controller);

        assertThatThrownBy(() ->
                new RouteTable(List.of(duplicate, duplicate)))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessageContaining("duplicate route")
                .hasMessageContaining("GET /posts/detail");
    }

    @Test
    void mappingReturnsFoundMethodNotAllowedAndNotFound() {
        PageController controller = () -> new ModelView(
                "post-detail", new PageModel(42L, "매핑 결과"));
        var table = new RouteTable(List.of(new Route(
                new RouteKey(RouteMethod.GET, "/posts/detail"),
                controller)));

        assertThat(table.match(new RouteKey(
                RouteMethod.GET, "/posts/detail")))
                .isInstanceOf(Found.class);

        var rejected = table.match(new RouteKey(
                RouteMethod.PUT, "/posts/detail"));
        assertThat(rejected).isInstanceOf(MethodNotAllowed.class);
        assertThat(((MethodNotAllowed) rejected).allowedMethods())
                .containsExactly(RouteMethod.GET);

        assertThat(table.match(new RouteKey(
                RouteMethod.GET, "/missing")))
                .isEqualTo(new NotFound());
    }

    @Test
    void foundInvokesHandlerThenViewExactlyOnceInOrder() {
        var events = new ArrayList<String>();
        var handlerCalls = new AtomicInteger();
        var viewCalls = new AtomicInteger();
        PageController controller = () -> {
            handlerCalls.incrementAndGet();
            events.add("handler");
            return new ModelView(
                    "post-detail",
                    new PageModel(42L, "실행 순서"));
        };
        ViewBoundary view = model -> {
            viewCalls.incrementAndGet();
            events.add("view");
            return "post-detail:" + model.postId();
        };
        var front = frontController(controller, view);

        var result = front.dispatch(
                RouteMethod.GET, "/posts/detail");

        assertThat(result)
                .isEqualTo(new Rendered("post-detail:42"));
        assertThat(events).containsExactly("handler", "view");
        assertThat(handlerCalls).hasValue(1);
        assertThat(viewCalls).hasValue(1);
    }

    @Test
    void failuresInvokeNeitherHandlerNorView() {
        var handlerCalls = new AtomicInteger();
        var viewCalls = new AtomicInteger();
        PageController controller = () -> {
            handlerCalls.incrementAndGet();
            return new ModelView(
                    "post-detail",
                    new PageModel(42L, "호출되면 안 됨"));
        };
        ViewBoundary view = model -> {
            viewCalls.incrementAndGet();
            return "post-detail:" + model.postId();
        };
        var front = frontController(controller, view);

        assertThat(front.dispatch(
                RouteMethod.PUT, "/posts/detail"))
                .isInstanceOf(Rejected.class);
        assertThat(front.dispatch(
                RouteMethod.GET, "/missing"))
                .isEqualTo(new Missing());
        assertThat(handlerCalls).hasValue(0);
        assertThat(viewCalls).hasValue(0);
    }

    @Test
    void rootAndNamedContextsDeriveTheSameRawPathAndExcludeQuery() {
        var root = new ServletTarget(
                "/posts/%2Fdetail", "", "trace=root");
        var named = new ServletTarget(
                "/board/posts/%2Fdetail",
                "/board",
                "trace=named");

        assertThat(root.contextRelativeRawPath())
                .isEqualTo("/posts/%2Fdetail");
        assertThat(named.contextRelativeRawPath())
                .isEqualTo(root.contextRelativeRawPath());
        assertThat(root.queryString())
                .isNotEqualTo(named.queryString());
        assertThatThrownBy(() -> new ServletTarget(
                "/boardwalk/posts", "/board", null)
                .contextRelativeRawPath())
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessageContaining("context path boundary");
    }

    @Test
    void embeddedTomcatReturns200Then405WithExactAllowThen404()
            throws Exception {
        var handlerCalls = new AtomicInteger();
        var viewCalls = new AtomicInteger();
        PageController controller = () -> {
            handlerCalls.incrementAndGet();
            return new ModelView(
                    "post-detail",
                    new PageModel(42L, "컨테이너 확인"));
        };
        ViewBoundary view = model -> {
            viewCalls.incrementAndGet();
            return "post-detail:" + model.postId();
        };
        var servlet = new FrontControllerServlet(
                frontController(controller, view));
        var tomcat = new Tomcat();
        tomcat.setBaseDir(tomcatBase.toString());
        tomcat.setPort(0);
        tomcat.getConnector();
        var context = tomcat.addContext(
                "/board", tomcatBase.toString());
        Tomcat.addServlet(context, "front", servlet);
        context.addServletMappingDecoded("/*", "front");

        var started = false;
        try {
            tomcat.start();
            started = true;
            var base = "http://127.0.0.1:"
                    + tomcat.getConnector().getLocalPort()
                    + "/board";
            var client = HttpClient.newHttpClient();

            var success = client.send(
                    HttpRequest.newBuilder(URI.create(
                                    base
                                            + "/posts/detail"
                                            + "?trace=ignored"))
                            .GET()
                            .build(),
                    HttpResponse.BodyHandlers.ofString(
                            StandardCharsets.UTF_8));
            var rejected = client.send(
                    HttpRequest.newBuilder(URI.create(
                                    base + "/posts/detail"))
                            .PUT(HttpRequest.BodyPublishers.noBody())
                            .build(),
                    HttpResponse.BodyHandlers.ofString(
                            StandardCharsets.UTF_8));
            var missing = client.send(
                    HttpRequest.newBuilder(URI.create(
                                    base + "/missing"))
                            .GET()
                            .build(),
                    HttpResponse.BodyHandlers.ofString(
                            StandardCharsets.UTF_8));

            assertThat(success.statusCode()).isEqualTo(200);
            assertThat(success.body()).isEqualTo("post-detail:42");
            assertThat(rejected.statusCode()).isEqualTo(405);
            assertThat(rejected.headers().firstValue("Allow"))
                    .contains("GET, HEAD, OPTIONS");
            assertThat(missing.statusCode()).isEqualTo(404);
            assertThat(missing.headers().firstValue("Allow"))
                    .isEmpty();
            assertThat(handlerCalls).hasValue(1);
            assertThat(viewCalls).hasValue(1);
        } finally {
            if (started) {
                tomcat.stop();
            }
            tomcat.destroy();
        }
    }

    private static FrontController frontController(
            PageController controller,
            ViewBoundary view) {
        var routes = new RouteTable(List.of(new Route(
                new RouteKey(
                        RouteMethod.GET, "/posts/detail"),
                controller)));
        return new FrontController(
                routes, new ExactViewRegistry(view));
    }

    enum RouteMethod {
        GET,
        POST,
        PUT,
        DELETE,
        PATCH;

        static RouteMethod parseExact(String token) {
            Objects.requireNonNull(token, "method token");
            for (var method : values()) {
                if (method.name().equals(token)) {
                    return method;
                }
            }
            throw new IllegalArgumentException(
                    "unsupported method token: " + token);
        }
    }

    record RouteKey(RouteMethod method, String rawPath) {
        RouteKey {
            Objects.requireNonNull(method, "method");
            Objects.requireNonNull(rawPath, "rawPath");
            if (!rawPath.startsWith("/")) {
                throw new IllegalArgumentException(
                        "raw path must start with /");
            }
            if (rawPath.indexOf('?') >= 0) {
                throw new IllegalArgumentException(
                        "query is not part of a route key");
            }
        }

        static RouteKey parse(String method, String rawPath) {
            return new RouteKey(
                    RouteMethod.parseExact(method), rawPath);
        }

        @Override
        public String toString() {
            return method + " " + rawPath;
        }
    }

    record Route(RouteKey key, PageController controller) {
        Route {
            Objects.requireNonNull(key, "key");
            Objects.requireNonNull(controller, "controller");
        }
    }

    @FunctionalInterface
    interface PageController {
        ModelView handle();
    }

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

    record ModelView(String logicalView, PageModel model) {
        ModelView {
            Objects.requireNonNull(logicalView, "logicalView");
            Objects.requireNonNull(model, "model");
        }
    }

    @FunctionalInterface
    interface ViewBoundary {
        String render(PageModel model);
    }

    static final class ExactViewRegistry {
        private final Map<String, ViewBoundary> views;

        ExactViewRegistry(ViewBoundary postDetailView) {
            views = Map.of(
                    "post-detail",
                    Objects.requireNonNull(
                            postDetailView, "postDetailView"));
        }

        ViewBoundary resolve(String logicalView) {
            var view = views.get(logicalView);
            if (view == null) {
                throw new IllegalArgumentException(
                        "unregistered logical view: "
                                + logicalView);
            }
            return view;
        }
    }

    sealed interface Match
            permits Found, MethodNotAllowed, NotFound {}

    record Found(PageController controller) implements Match {
        Found {
            Objects.requireNonNull(controller, "controller");
        }
    }

    record MethodNotAllowed(Set<RouteMethod> allowedMethods)
            implements Match {
        MethodNotAllowed {
            Objects.requireNonNull(
                    allowedMethods, "allowedMethods");
            if (allowedMethods.isEmpty()) {
                throw new IllegalArgumentException(
                        "allowedMethods must not be empty");
            }
            allowedMethods = Collections.unmodifiableSet(
                    EnumSet.copyOf(allowedMethods));
        }
    }

    record NotFound() implements Match {}

    static final class RouteTable {
        private final Map<RouteKey, PageController> handlers;
        private final Map<String, Set<RouteMethod>> methodsByPath;

        RouteTable(List<Route> registrations) {
            Objects.requireNonNull(
                    registrations, "registrations");
            var mutableHandlers =
                    new LinkedHashMap<RouteKey, PageController>();
            var mutableMethods =
                    new LinkedHashMap<String, EnumSet<RouteMethod>>();
            for (var route : registrations) {
                Objects.requireNonNull(route, "route");
                if (mutableHandlers.putIfAbsent(
                                route.key(), route.controller())
                        != null) {
                    throw new IllegalArgumentException(
                            "duplicate route: " + route.key());
                }
                mutableMethods
                        .computeIfAbsent(
                                route.key().rawPath(),
                                ignored -> EnumSet.noneOf(
                                        RouteMethod.class))
                        .add(route.key().method());
            }
            handlers = Collections.unmodifiableMap(
                    new LinkedHashMap<>(mutableHandlers));

            var frozenMethods =
                    new LinkedHashMap<String, Set<RouteMethod>>();
            mutableMethods.forEach((path, methods) ->
                    frozenMethods.put(
                            path,
                            Collections.unmodifiableSet(
                                    EnumSet.copyOf(methods))));
            methodsByPath = Collections.unmodifiableMap(
                    frozenMethods);
        }

        Match match(RouteKey key) {
            var controller = handlers.get(key);
            if (controller != null) {
                return new Found(controller);
            }
            var allowed = methodsByPath.get(key.rawPath());
            if (allowed != null) {
                return new MethodNotAllowed(allowed);
            }
            return new NotFound();
        }

        Optional<Set<RouteMethod>> registeredMethods(
                String rawPath) {
            return Optional.ofNullable(
                    methodsByPath.get(rawPath));
        }
    }

    sealed interface DispatchResult
            permits Rendered, Rejected, Missing {}

    record Rendered(String marker) implements DispatchResult {
        Rendered {
            Objects.requireNonNull(marker, "marker");
        }
    }

    record Rejected(Set<RouteMethod> allowedMethods)
            implements DispatchResult {
        Rejected {
            allowedMethods = Collections.unmodifiableSet(
                    EnumSet.copyOf(allowedMethods));
        }
    }

    record Missing() implements DispatchResult {}

    static final class FrontController {
        private final RouteTable routes;
        private final ExactViewRegistry views;

        FrontController(
                RouteTable routes,
                ExactViewRegistry views) {
            this.routes = Objects.requireNonNull(
                    routes, "routes");
            this.views = Objects.requireNonNull(
                    views, "views");
        }

        DispatchResult dispatch(
                RouteMethod method, String rawPath) {
            return switch (routes.match(
                    new RouteKey(method, rawPath))) {
                case Found found -> {
                    var modelView =
                            found.controller().handle();
                    var view = views.resolve(
                            modelView.logicalView());
                    yield new Rendered(
                            view.render(modelView.model()));
                }
                case MethodNotAllowed rejected ->
                    new Rejected(rejected.allowedMethods());
                case NotFound ignored -> new Missing();
            };
        }

        Optional<Set<RouteMethod>> registeredMethods(
                String rawPath) {
            return routes.registeredMethods(rawPath);
        }
    }

    record ServletTarget(
            String requestUri,
            String contextPath,
            String queryString) {
        ServletTarget {
            Objects.requireNonNull(requestUri, "requestUri");
            Objects.requireNonNull(contextPath, "contextPath");
            if (requestUri.indexOf('?') >= 0) {
                throw new IllegalArgumentException(
                        "requestUri must end before ?");
            }
        }

        String contextRelativeRawPath() {
            if (!contextPath.isEmpty()
                    && (!requestUri.startsWith(contextPath)
                            || (requestUri.length()
                                            > contextPath.length()
                                    && requestUri.charAt(
                                                    contextPath.length())
                                            != '/'))) {
                throw new IllegalArgumentException(
                        "request URI violates context path boundary");
            }
            var rawPath = requestUri.substring(
                    contextPath.length());
            return rawPath.isEmpty() ? "/" : rawPath;
        }
    }

    static final class FrontControllerServlet
            extends HttpServlet {
        private final FrontController front;

        FrontControllerServlet(FrontController front) {
            this.front = Objects.requireNonNull(
                    front, "front");
        }

        @Override
        protected void doGet(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            dispatch(RouteMethod.GET, request, response);
        }

        @Override
        protected void doPost(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            dispatch(RouteMethod.POST, request, response);
        }

        @Override
        protected void doPut(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            dispatch(RouteMethod.PUT, request, response);
        }

        @Override
        protected void doDelete(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            dispatch(RouteMethod.DELETE, request, response);
        }

        @Override
        protected void doPatch(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            dispatch(RouteMethod.PATCH, request, response);
        }

        @Override
        protected void doOptions(
                HttpServletRequest request,
                HttpServletResponse response) {
            var target = target(request);
            var registered = front.registeredMethods(
                    target.contextRelativeRawPath());
            if (registered.isEmpty()) {
                response.setStatus(
                        HttpServletResponse.SC_NOT_FOUND);
                return;
            }
            response.setHeader(
                    "Allow", effectiveAllow(registered.orElseThrow()));
            response.setStatus(HttpServletResponse.SC_OK);
        }

        private void dispatch(
                RouteMethod method,
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            var target = target(request);
            switch (front.dispatch(
                    method, target.contextRelativeRawPath())) {
                case Rendered rendered -> {
                    response.setStatus(HttpServletResponse.SC_OK);
                    response.setContentType("text/plain");
                    response.setCharacterEncoding(
                            StandardCharsets.UTF_8.name());
                    response.getWriter().write(
                            rendered.marker());
                }
                case Rejected rejected -> {
                    response.setHeader(
                            "Allow",
                            effectiveAllow(
                                    rejected.allowedMethods()));
                    response.setStatus(
                            HttpServletResponse
                                    .SC_METHOD_NOT_ALLOWED);
                }
                case Missing ignored -> response.setStatus(
                        HttpServletResponse.SC_NOT_FOUND);
            }
        }

        private static ServletTarget target(
                HttpServletRequest request) {
            return new ServletTarget(
                    request.getRequestURI(),
                    request.getContextPath(),
                    request.getQueryString());
        }

        private static String effectiveAllow(
                Set<RouteMethod> registered) {
            var tokens = new ArrayList<String>();
            for (var method : RouteMethod.values()) {
                if (!registered.contains(method)) {
                    continue;
                }
                tokens.add(method.name());
                if (method == RouteMethod.GET) {
                    tokens.add("HEAD");
                }
            }
            // OPTIONS is present because this adapter implements
            // doOptions for every known path.
            tokens.add("OPTIONS");
            return String.join(", ", tokens);
        }
    }
}