MVC 역할 경계

package board.mvc;

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
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.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpStatus;
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.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;

public class MvcRoleBoundaryTest {
    @Test
    void valid_input_is_queried_once_and_becomes_the_exact_page_contract() {
        var query = new RecordingPostQuery(samplePost());
        var controller = controller(query);

        var result = controller.handle(
                Map.of("id", List.of("42")));

        var expected = expectedPageModel();
        assertAll(
                () -> assertEquals(1, query.invocations()),
                () -> assertEquals(
                        List.of(42L),
                        query.requestedIds()),
                () -> assertEquals(
                        "post-detail",
                        result.viewName()),
                () -> assertEquals(
                        Map.of("post", expected),
                        result.model()),
                () -> assertSame(
                        PostPageModel.class,
                        result.model().get("post").getClass()));
    }

    @Test
    void every_invalid_id_fails_before_the_query() {
        var cases = List.of(
                new InputCase("missing", Map.of()),
                new InputCase(
                        "empty list",
                        Map.of("id", List.of())),
                new InputCase(
                        "duplicate",
                        Map.of(
                                "id",
                                List.of("41", "42"))),
                new InputCase(
                        "blank",
                        Map.of("id", List.of(" "))),
                new InputCase(
                        "nonnumeric",
                        Map.of("id", List.of("forty-two"))),
                new InputCase(
                        "zero",
                        Map.of("id", List.of("0"))),
                new InputCase(
                        "negative",
                        Map.of("id", List.of("-1"))),
                new InputCase(
                        "overflow",
                        Map.of(
                                "id",
                                List.of("9223372036854775808"))));

        for (var input : cases) {
            var query = new RecordingPostQuery(samplePost());
            var controller = controller(query);

            var exception = assertThrows(
                    BadRequestException.class,
                    () -> controller.handle(
                            input.parameters()),
                    input.label());

            assertAll(
                    input.label(),
                    () -> assertTrue(
                            exception.getMessage()
                                    .contains("id")),
                    () -> assertEquals(
                            0,
                            query.invocations()));
        }
    }

    @Test
    void page_model_has_only_the_declared_primitive_and_string_shape() {
        var components =
                PostPageModel.class.getRecordComponents();

        assertAll(
                () -> assertArrayEquals(
                        new String[] {
                            "id",
                            "title",
                            "bodyText",
                            "contentLength",
                            "showLongReadBadge"
                        },
                        Arrays.stream(components)
                                .map(component ->
                                        component.getName())
                                .toArray(String[]::new)),
                () -> assertArrayEquals(
                        new Class<?>[] {
                            long.class,
                            String.class,
                            String.class,
                            int.class,
                            boolean.class
                        },
                        Arrays.stream(components)
                                .map(component ->
                                        component.getType())
                                .toArray(Class<?>[]::new)));
    }

    @Test
    void map_copy_of_is_an_unmodifiable_shallow_snapshot() {
        var mutableValue = new ArrayList<>(
                List.of("before"));
        var source = new HashMap<String, Object>();
        source.put("items", mutableValue);

        var result = new ModelView(
                "post-detail",
                source);
        source.put("added later", "not copied");

        assertAll(
                () -> assertFalse(
                        result.model()
                                .containsKey("added later")),
                () -> assertThrows(
                        UnsupportedOperationException.class,
                        () -> result.model().put(
                                "new key",
                                "new value")));

        mutableValue.add("after");

        assertEquals(
                List.of("before", "after"),
                result.model().get("items"));
    }

    @Test
    void view_registry_accepts_only_an_exact_allowed_name() {
        var allowedView = new RecordingView();
        var registry = ExactViewRegistry.postDetailOnly(
                allowedView);

        assertSame(
                allowedView,
                registry.resolveViewName(
                        "post-detail",
                        Locale.KOREA));
        assertThrows(
                UnknownViewException.class,
                () -> registry.resolveViewName(
                        "post-list",
                        Locale.KOREA));

        for (var pathLike : List.of(
                "../secret",
                "/WEB-INF/views/post-detail.jsp",
                "post-detail.jsp",
                "post\\detail",
                "file:post-detail")) {
            assertThrows(
                    IllegalArgumentException.class,
                    () -> registry.resolveViewName(
                            pathLike,
                            Locale.KOREA),
                    pathLike);
        }
    }

    @Test
    void standalone_mock_mvc_exposes_the_valid_model_and_view()
            throws Exception {
        var query = new RecordingPostQuery(samplePost());
        var fixture = springFixture(query);
        var expected = expectedPageModel();

        fixture.mvc()
                .perform(get("/posts/detail")
                        .queryParam("id", "42"))
                .andExpect(status().isOk())
                .andExpect(view().name("post-detail"))
                .andExpect(model().attribute(
                        "post",
                        expected));

        assertAll(
                () -> assertEquals(
                        1,
                        query.invocations()),
                () -> assertEquals(
                        List.of(42L),
                        query.requestedIds()),
                () -> assertEquals(
                        1,
                        fixture.view().renders()),
                () -> assertEquals(
                        expected,
                        fixture.view()
                                .lastModel()
                                .get("post")));
    }

    @Test
    void standalone_mock_mvc_maps_nonnumeric_input_to_400_without_query()
            throws Exception {
        var query = new RecordingPostQuery(samplePost());
        var fixture = springFixture(query);

        var result = fixture.mvc()
                .perform(get("/posts/detail")
                        .queryParam("id", "not-a-number"))
                .andExpect(status().isBadRequest())
                .andReturn();

        assertAll(
                () -> assertInstanceOf(
                        BadRequestException.class,
                        result.getResolvedException()),
                () -> assertEquals(
                        0,
                        query.invocations()),
                () -> assertEquals(
                        0,
                        fixture.view().renders()));
    }

    private static PostDetailPageController controller(
            PostQuery query) {
        return new PostDetailPageController(
                query,
                new PostPageModelMapper());
    }

    private static SpringFixture springFixture(
            RecordingPostQuery query) {
        var view = new RecordingView();
        var registry = ExactViewRegistry.postDetailOnly(
                view);
        MockMvc mvc = MockMvcBuilders
                .standaloneSetup(
                        new SpringPageAdapter(
                                controller(query)))
                .setViewResolvers(registry)
                .build();
        return new SpringFixture(mvc, view);
    }

    private static Post samplePost() {
        return new Post(
                42L,
                "<b>MVC boundary</b>",
                "request text, not prebuilt HTML",
                80,
                "internal moderation note");
    }

    private static PostPageModel expectedPageModel() {
        return new PostPageModel(
                42L,
                "<b>MVC boundary</b>",
                "request text, not prebuilt HTML",
                80,
                true);
    }

    @FunctionalInterface
    interface PageController {
        ModelView handle(
                Map<String, List<String>> parameters);
    }

    record ModelView(
            String viewName,
            Map<String, Object> model) {
        ModelView {
            viewName = Objects.requireNonNull(
                    viewName,
                    "viewName");
            if (viewName.isBlank()) {
                throw new IllegalArgumentException(
                        "viewName must not be blank");
            }
            model = Map.copyOf(
                    Objects.requireNonNull(
                            model,
                            "model"));
        }
    }

    static final class RequiredPositiveId {
        private RequiredPositiveId() {}

        static long from(
                Map<String, List<String>> parameters) {
            Objects.requireNonNull(
                    parameters,
                    "parameters");
            var values = parameters.get("id");
            if (values == null || values.size() != 1) {
                throw new BadRequestException(
                        "id must appear exactly once");
            }

            var raw = values.getFirst();
            if (raw == null || raw.isBlank()) {
                throw new BadRequestException(
                        "id must be a positive integer");
            }

            final long id;
            try {
                id = Long.parseLong(raw);
            } catch (NumberFormatException exception) {
                throw new BadRequestException(
                        "id must be a positive integer",
                        exception);
            }
            if (id <= 0) {
                throw new BadRequestException(
                        "id must be positive");
            }
            return id;
        }
    }

    interface PostQuery {
        Post required(long id);
    }

    record Post(
            long id,
            String title,
            String bodyText,
            int contentLength,
            String moderationNote) {
        Post {
            if (id <= 0) {
                throw new IllegalArgumentException(
                        "id must be positive");
            }
            title = Objects.requireNonNull(
                    title,
                    "title");
            bodyText = Objects.requireNonNull(
                    bodyText,
                    "bodyText");
            if (contentLength < 0) {
                throw new IllegalArgumentException(
                        "contentLength must not be negative");
            }
            moderationNote = Objects.requireNonNull(
                    moderationNote,
                    "moderationNote");
        }
    }

    record PostPageModel(
            long id,
            String title,
            String bodyText,
            int contentLength,
            boolean showLongReadBadge) {}

    static final class PostPageModelMapper {
        PostPageModel map(Post post) {
            Objects.requireNonNull(post, "post");
            return new PostPageModel(
                    post.id(),
                    post.title(),
                    post.bodyText(),
                    post.contentLength(),
                    post.contentLength() >= 60);
        }
    }

    static final class PostDetailPageController
            implements PageController {
        private static final String VIEW_NAME =
                "post-detail";

        private final PostQuery query;
        private final PostPageModelMapper mapper;

        PostDetailPageController(
                PostQuery query,
                PostPageModelMapper mapper) {
            this.query = Objects.requireNonNull(
                    query,
                    "query");
            this.mapper = Objects.requireNonNull(
                    mapper,
                    "mapper");
        }

        @Override
        public ModelView handle(
                Map<String, List<String>> parameters) {
            var id = RequiredPositiveId.from(parameters);
            var post = query.required(id);
            var page = mapper.map(post);
            return new ModelView(
                    VIEW_NAME,
                    Map.of("post", page));
        }
    }

    @Controller
    static final class SpringPageAdapter {
        private final PostDetailPageController delegate;

        SpringPageAdapter(
                PostDetailPageController delegate) {
            this.delegate = Objects.requireNonNull(
                    delegate,
                    "delegate");
        }

        @GetMapping("/posts/detail")
        String detail(
                @RequestParam(
                        name = "id",
                        required = false)
                List<String> idValues,
                Model model) {
            var parameters = idValues == null
                    ? Map.<String, List<String>>of()
                    : Map.of(
                            "id",
                            List.copyOf(idValues));
            var result = delegate.handle(parameters);
            model.addAllAttributes(result.model());
            return result.viewName();
        }
    }

    static final class ExactViewRegistry
            implements ViewResolver {
        private final Map<String, View> allowed;

        private ExactViewRegistry(
                Map<String, View> allowed) {
            Objects.requireNonNull(allowed, "allowed");
            if (allowed.isEmpty()) {
                throw new IllegalArgumentException(
                        "at least one view is required");
            }
            allowed.forEach((name, view) -> {
                rejectPathLikeName(name);
                Objects.requireNonNull(
                        view,
                        "view for " + name);
            });
            this.allowed = Map.copyOf(allowed);
        }

        static ExactViewRegistry postDetailOnly(
                View postDetail) {
            return new ExactViewRegistry(
                    Map.of(
                            "post-detail",
                            Objects.requireNonNull(
                                    postDetail,
                                    "postDetail")));
        }

        @Override
        public View resolveViewName(
                String viewName,
                Locale locale) {
            Objects.requireNonNull(locale, "locale");
            rejectPathLikeName(viewName);
            var resolved = allowed.get(viewName);
            if (resolved == null) {
                throw new UnknownViewException(viewName);
            }
            return resolved;
        }

        private static void rejectPathLikeName(
                String viewName) {
            if (viewName == null || viewName.isBlank()) {
                throw new IllegalArgumentException(
                        "view name must not be blank");
            }
            if (viewName.contains("/")
                    || viewName.contains("\\")
                    || viewName.contains("..")
                    || viewName.contains(":")
                    || viewName.endsWith(".jsp")
                    || viewName.endsWith(".html")) {
                throw new IllegalArgumentException(
                        "path-like view name is forbidden");
            }
        }
    }

    static final class RecordingPostQuery
            implements PostQuery {
        private final Post answer;
        private final List<Long> requestedIds =
                new ArrayList<>();

        RecordingPostQuery(Post answer) {
            this.answer = Objects.requireNonNull(
                    answer,
                    "answer");
        }

        @Override
        public Post required(long id) {
            requestedIds.add(id);
            return answer;
        }

        int invocations() {
            return requestedIds.size();
        }

        List<Long> requestedIds() {
            return List.copyOf(requestedIds);
        }
    }

    static final class RecordingView implements View {
        private int renders;
        private Map<String, ?> lastModel = Map.of();

        @Override
        public String getContentType() {
            return "text/plain;charset=UTF-8";
        }

        @Override
        public void render(
                Map<String, ?> model,
                HttpServletRequest request,
                HttpServletResponse response)
                throws Exception {
            renders++;
            lastModel = Map.copyOf(model);
            response.setContentType(getContentType());
            response.getWriter().write(
                    "fixed test view");
        }

        int renders() {
            return renders;
        }

        Map<String, ?> lastModel() {
            return lastModel;
        }
    }

    @ResponseStatus(HttpStatus.BAD_REQUEST)
    static final class BadRequestException
            extends RuntimeException {
        BadRequestException(String message) {
            super(message);
        }

        BadRequestException(
                String message,
                Throwable cause) {
            super(message, cause);
        }
    }

    static final class UnknownViewException
            extends RuntimeException {
        UnknownViewException(String viewName) {
            super("unknown view: " + viewName);
        }
    }

    record InputCase(
            String label,
            Map<String, List<String>> parameters) {}

    record SpringFixture(
            MockMvc mvc,
            RecordingView view) {}
}