HandlerAdapter 확장

package board.mvc;

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiConsumer;
import java.util.function.Function;
import org.junit.jupiter.api.Test;

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

    @Test
    void registeredHandlersAreBoundToExactlyOneAdapter() {
        var trace = new Trace();
        var page = new NamedPageController(
                "page",
                input -> ModelView.postDetail(
                        new PostPageModel(input.postId(), "Adapter boundary")));
        var legacy = new NamedLegacyController(
                (input, marker) -> marker.mark("legacy:" + input.postId()));
        var pageAdapter = new PageControllerAdapter(trace);
        var legacyAdapter = new LegacyControllerAdapter(trace);

        var registry = new HandlerAdapterRegistry(
                List.of(page, legacy),
                List.of(pageAdapter, legacyAdapter));

        assertThat(registry.required(page)).isSameAs(pageAdapter);
        assertThat(registry.required(legacy)).isSameAs(legacyAdapter);
        assertThat(registry.bindingCount()).isEqualTo(2);
        assertThat(pageAdapter.supportsCalls()).isEqualTo(2);
        assertThat(legacyAdapter.supportsCalls()).isEqualTo(2);
        assertThat(pageAdapter.handleCalls()).isZero();
        assertThat(legacyAdapter.handleCalls()).isZero();
        assertThat(page.calls()).isZero();
        assertThat(legacy.calls()).isZero();
    }

    @Test
    void missingAdapterFailsDuringConstruction() {
        var trace = new Trace();
        var page = new NamedPageController(
                "missing",
                input -> ModelView.postDetail(
                        new PostPageModel(input.postId(), "never")));
        var unrelated = new LegacyControllerAdapter(trace);

        assertThatThrownBy(() -> new HandlerAdapterRegistry(
                        List.of(page),
                        List.of(unrelated)))
                .isInstanceOf(AdapterConfigurationException.class)
                .hasMessage(
                        "Expected exactly one adapter for "
                                + "NamedPageController; found 0");

        assertThat(unrelated.supportsCalls()).isOne();
        assertThat(unrelated.handleCalls()).isZero();
        assertThat(page.calls()).isZero();
        assertThat(trace.snapshot()).isEmpty();
    }

    @Test
    void overlappingAdaptersFailDuringConstruction() {
        var trace = new Trace();
        var page = new NamedPageController(
                "overlap",
                input -> ModelView.postDetail(
                        new PostPageModel(input.postId(), "never")));
        var first = new PageControllerAdapter(trace);
        var second = new PageControllerAdapter(trace);

        assertThatThrownBy(() -> new HandlerAdapterRegistry(
                        List.of(page),
                        List.of(first, second)))
                .isInstanceOf(AdapterConfigurationException.class)
                .hasMessage(
                        "Expected exactly one adapter for "
                                + "NamedPageController; found 2");

        assertThat(first.supportsCalls()).isOne();
        assertThat(second.supportsCalls()).isOne();
        assertThat(first.handleCalls()).isZero();
        assertThat(second.handleCalls()).isZero();
        assertThat(page.calls()).isZero();
        assertThat(trace.snapshot()).isEmpty();
    }

    @Test
    void dispatchUsesFrozenIdentityBindingWithoutRescanning() {
        var trace = new Trace();
        var page = new NamedPageController(
                "frozen",
                input -> ModelView.postDetail(
                        new PostPageModel(input.postId(), "Frozen")));
        var selected = new PageControllerAdapter(trace);
        var unrelated = new LegacyControllerAdapter(trace);
        var configured = new ArrayList<HandlerAdapter>();
        configured.add(selected);
        configured.add(unrelated);
        var registry = new HandlerAdapterRegistry(
                List.of(page), configured);
        var supportsBeforeDispatch = List.of(
                selected.supportsCalls(), unrelated.supportsCalls());
        var view = new FixedTestView(trace);
        var views = new ExactViewRegistry(trace, view);
        var dispatcher = new HandlerAdapterDispatcher(registry, views);
        var marker = new ObservationMarker();

        configured.clear();
        configured.add(unrelated);
        dispatcher.dispatch(new HandlerInput(42), page, marker);

        assertThat(List.of(
                        selected.supportsCalls(),
                        unrelated.supportsCalls()))
                .isEqualTo(supportsBeforeDispatch);
        assertThat(selected.handleCalls()).isOne();
        assertThat(unrelated.handleCalls()).isZero();
        assertThat(page.calls()).isOne();
        assertThat(views.lookupCalls()).isOne();
        assertThat(view.renderCalls()).isOne();
        assertThat(marker.value()).isEqualTo("post-detail:42");
    }

    @Test
    void modelViewResultResolvesAndInvokesFixedViewOnceInOrder() {
        var trace = new Trace();
        var pageModel = new PostPageModel(42, "Typed page model");
        var page = new NamedPageController("detail", input -> {
            trace.add("page-controller");
            return ModelView.postDetail(pageModel);
        });
        var adapter = new PageControllerAdapter(trace);
        var registry = new HandlerAdapterRegistry(
                List.of(page), List.of(adapter));
        var view = new FixedTestView(trace);
        var views = new ExactViewRegistry(trace, view);
        var dispatcher = new HandlerAdapterDispatcher(registry, views);
        var marker = new ObservationMarker();

        dispatcher.dispatch(new HandlerInput(42), page, marker);

        assertThat(trace.snapshot()).containsExactly(
                "page-adapter",
                "page-controller",
                "view-registry",
                "fixed-view");
        assertThat(adapter.handleCalls()).isOne();
        assertThat(page.calls()).isOne();
        assertThat(views.lookupCalls()).isOne();
        assertThat(views.lastLogicalName()).isEqualTo(POST_DETAIL);
        assertThat(view.renderCalls()).isOne();
        assertThat(view.lastModel()).isExactlyInstanceOf(PostPageModel.class);
        assertThat(view.lastModel()).isEqualTo(pageModel);
        assertThat(marker.writes()).isOne();
        assertThat(marker.value()).isEqualTo("post-detail:42");
    }

    @Test
    void responseHandledSkipsRegistryAndView() {
        var trace = new Trace();
        var legacy = new NamedLegacyController((input, marker) -> {
            trace.add("legacy-controller");
            marker.mark("legacy:" + input.postId());
        });
        var adapter = new LegacyControllerAdapter(trace);
        var registry = new HandlerAdapterRegistry(
                List.of(legacy), List.of(adapter));
        var view = new FixedTestView(trace);
        var views = new ExactViewRegistry(trace, view);
        var dispatcher = new HandlerAdapterDispatcher(registry, views);
        var marker = new ObservationMarker();

        dispatcher.dispatch(new HandlerInput(42), legacy, marker);

        assertThat(trace.snapshot()).containsExactly(
                "legacy-adapter", "legacy-controller");
        assertThat(adapter.handleCalls()).isOne();
        assertThat(legacy.calls()).isOne();
        assertThat(views.lookupCalls()).isZero();
        assertThat(view.renderCalls()).isZero();
        assertThat(marker.writes()).isOne();
        assertThat(marker.value()).isEqualTo("legacy:42");
    }

    @Test
    void unregisteredHandlerFailsWithoutDownstreamCalls() {
        var trace = new Trace();
        var registered = new NamedPageController(
                "same-value",
                input -> ModelView.postDetail(
                        new PostPageModel(input.postId(), "registered")));
        var equalButUnregistered = new NamedPageController(
                "same-value",
                input -> ModelView.postDetail(
                        new PostPageModel(input.postId(), "unregistered")));
        var adapter = new PageControllerAdapter(trace);
        var registry = new HandlerAdapterRegistry(
                List.of(registered), List.of(adapter));
        var supportsAfterConstruction = adapter.supportsCalls();
        var view = new FixedTestView(trace);
        var views = new ExactViewRegistry(trace, view);
        var dispatcher = new HandlerAdapterDispatcher(registry, views);
        var marker = new ObservationMarker();

        assertThat(equalButUnregistered)
                .isEqualTo(registered)
                .isNotSameAs(registered);
        assertThatThrownBy(() -> dispatcher.dispatch(
                        new HandlerInput(42),
                        equalButUnregistered,
                        marker))
                .isInstanceOf(UnregisteredHandlerException.class)
                .hasMessage(
                        "Unregistered handler instance: "
                                + "NamedPageController");

        assertThat(adapter.supportsCalls())
                .isEqualTo(supportsAfterConstruction);
        assertThat(adapter.handleCalls()).isZero();
        assertThat(registered.calls()).isZero();
        assertThat(equalButUnregistered.calls()).isZero();
        assertThat(views.lookupCalls()).isZero();
        assertThat(view.renderCalls()).isZero();
        assertThat(marker.writes()).isZero();
        assertThat(trace.snapshot()).isEmpty();
    }

    record HandlerInput(long postId) {}

    record PostPageModel(long id, String title) {
        PostPageModel {
            Objects.requireNonNull(title, "title");
        }
    }

    record ModelView(String viewName, PostPageModel model) {
        ModelView {
            if (!POST_DETAIL.equals(viewName)) {
                throw new IllegalArgumentException(
                        "Unknown logical view: " + viewName);
            }
            Objects.requireNonNull(model, "model");
        }

        static ModelView postDetail(PostPageModel model) {
            return new ModelView(POST_DETAIL, model);
        }
    }

    sealed interface AdapterResult
            permits ModelViewResult, ResponseHandled {}

    record ModelViewResult(ModelView modelView)
            implements AdapterResult {
        ModelViewResult {
            Objects.requireNonNull(modelView, "modelView");
        }
    }

    enum ResponseHandled implements AdapterResult {
        INSTANCE
    }

    @FunctionalInterface
    interface PageController {
        ModelView handle(HandlerInput input);
    }

    @FunctionalInterface
    interface LegacyController {
        void handle(HandlerInput input, ObservationMarker marker);
    }

    interface HandlerAdapter {
        boolean supports(Object handler);

        AdapterResult handle(
                HandlerInput input,
                Object handler,
                ObservationMarker marker);
    }

    interface ViewBoundary {
        void render(PostPageModel model, ObservationMarker marker);
    }

    static final class PageControllerAdapter
            implements HandlerAdapter {
        private final Trace trace;
        private final AtomicInteger supportsCalls = new AtomicInteger();
        private final AtomicInteger handleCalls = new AtomicInteger();

        PageControllerAdapter(Trace trace) {
            this.trace = Objects.requireNonNull(trace, "trace");
        }

        @Override
        public boolean supports(Object handler) {
            supportsCalls.incrementAndGet();
            return handler instanceof PageController;
        }

        @Override
        public AdapterResult handle(
                HandlerInput input,
                Object handler,
                ObservationMarker marker) {
            handleCalls.incrementAndGet();
            trace.add("page-adapter");
            var controller = (PageController) handler;
            return new ModelViewResult(controller.handle(input));
        }

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

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

    static final class LegacyControllerAdapter
            implements HandlerAdapter {
        private final Trace trace;
        private final AtomicInteger supportsCalls = new AtomicInteger();
        private final AtomicInteger handleCalls = new AtomicInteger();

        LegacyControllerAdapter(Trace trace) {
            this.trace = Objects.requireNonNull(trace, "trace");
        }

        @Override
        public boolean supports(Object handler) {
            supportsCalls.incrementAndGet();
            return handler instanceof LegacyController;
        }

        @Override
        public AdapterResult handle(
                HandlerInput input,
                Object handler,
                ObservationMarker marker) {
            handleCalls.incrementAndGet();
            trace.add("legacy-adapter");
            var controller = (LegacyController) handler;
            controller.handle(input, marker);
            return ResponseHandled.INSTANCE;
        }

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

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

    static final class HandlerAdapterRegistry {
        private final Map<Object, HandlerAdapter> bindings;

        HandlerAdapterRegistry(
                List<?> registeredHandlers,
                List<? extends HandlerAdapter> adapters) {
            Objects.requireNonNull(
                    registeredHandlers, "registeredHandlers");
            Objects.requireNonNull(adapters, "adapters");
            var candidates = List.copyOf(adapters);
            var seen = new IdentityHashMap<Object, Boolean>();
            var mutableBindings =
                    new IdentityHashMap<Object, HandlerAdapter>();

            for (var handler : registeredHandlers) {
                Objects.requireNonNull(handler, "registered handler");
                if (seen.put(handler, Boolean.TRUE) != null) {
                    continue;
                }

                var supporting = new ArrayList<HandlerAdapter>();
                for (var adapter : candidates) {
                    if (adapter.supports(handler)) {
                        supporting.add(adapter);
                    }
                }
                if (supporting.size() != 1) {
                    throw new AdapterConfigurationException(
                            "Expected exactly one adapter for "
                                    + handler.getClass().getSimpleName()
                                    + "; found "
                                    + supporting.size());
                }
                mutableBindings.put(handler, supporting.getFirst());
            }

            bindings = Collections.unmodifiableMap(mutableBindings);
        }

        HandlerAdapter required(Object handler) {
            Objects.requireNonNull(handler, "handler");
            if (!bindings.containsKey(handler)) {
                throw new UnregisteredHandlerException(
                        "Unregistered handler instance: "
                                + handler.getClass().getSimpleName());
            }
            return bindings.get(handler);
        }

        int bindingCount() {
            return bindings.size();
        }
    }

    static final class HandlerAdapterDispatcher {
        private final HandlerAdapterRegistry adapters;
        private final ExactViewRegistry views;

        HandlerAdapterDispatcher(
                HandlerAdapterRegistry adapters,
                ExactViewRegistry views) {
            this.adapters = Objects.requireNonNull(adapters, "adapters");
            this.views = Objects.requireNonNull(views, "views");
        }

        void dispatch(
                HandlerInput input,
                Object handler,
                ObservationMarker marker) {
            var adapter = adapters.required(handler);
            var result = Objects.requireNonNull(
                    adapter.handle(input, handler, marker),
                    "adapter result");

            switch (result) {
                case ModelViewResult page -> {
                    var modelView = page.modelView();
                    var view = views.resolve(modelView.viewName());
                    view.render(modelView.model(), marker);
                }
                case ResponseHandled ignored -> {
                    // The handler completed this tutorial boundary.
                }
            }
        }
    }

    static final class ExactViewRegistry {
        private final Trace trace;
        private final ViewBoundary fixedView;
        private final AtomicInteger lookupCalls = new AtomicInteger();
        private String lastLogicalName;

        ExactViewRegistry(Trace trace, ViewBoundary fixedView) {
            this.trace = Objects.requireNonNull(trace, "trace");
            this.fixedView = Objects.requireNonNull(fixedView, "fixedView");
        }

        ViewBoundary resolve(String logicalName) {
            lookupCalls.incrementAndGet();
            trace.add("view-registry");
            lastLogicalName = logicalName;
            if (!POST_DETAIL.equals(logicalName)) {
                throw new IllegalArgumentException(
                        "Unknown logical view: " + logicalName);
            }
            return fixedView;
        }

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

        String lastLogicalName() {
            return lastLogicalName;
        }
    }

    static final class FixedTestView implements ViewBoundary {
        private final Trace trace;
        private final AtomicInteger renderCalls = new AtomicInteger();
        private PostPageModel lastModel;

        FixedTestView(Trace trace) {
            this.trace = Objects.requireNonNull(trace, "trace");
        }

        @Override
        public void render(
                PostPageModel model,
                ObservationMarker marker) {
            renderCalls.incrementAndGet();
            trace.add("fixed-view");
            lastModel = Objects.requireNonNull(model, "model");
            marker.mark(POST_DETAIL + ":" + model.id());
        }

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

        PostPageModel lastModel() {
            return lastModel;
        }
    }

    static final class NamedPageController
            implements PageController {
        private final String equalityKey;
        private final Function<HandlerInput, ModelView> action;
        private final AtomicInteger calls = new AtomicInteger();

        NamedPageController(
                String equalityKey,
                Function<HandlerInput, ModelView> action) {
            this.equalityKey = Objects.requireNonNull(
                    equalityKey, "equalityKey");
            this.action = Objects.requireNonNull(action, "action");
        }

        @Override
        public ModelView handle(HandlerInput input) {
            calls.incrementAndGet();
            return action.apply(input);
        }

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

        @Override
        public boolean equals(Object other) {
            return other instanceof NamedPageController page
                    && equalityKey.equals(page.equalityKey);
        }

        @Override
        public int hashCode() {
            return equalityKey.hashCode();
        }
    }

    static final class NamedLegacyController
            implements LegacyController {
        private final BiConsumer<HandlerInput, ObservationMarker> action;
        private final AtomicInteger calls = new AtomicInteger();

        NamedLegacyController(
                BiConsumer<HandlerInput, ObservationMarker> action) {
            this.action = Objects.requireNonNull(action, "action");
        }

        @Override
        public void handle(
                HandlerInput input,
                ObservationMarker marker) {
            calls.incrementAndGet();
            action.accept(input, marker);
        }

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

    static final class ObservationMarker {
        private String value;
        private int writes;

        void mark(String nextValue) {
            Objects.requireNonNull(nextValue, "nextValue");
            if (writes != 0) {
                throw new IllegalStateException(
                        "Observation marker already written");
            }
            value = nextValue;
            writes++;
        }

        String value() {
            return value;
        }

        int writes() {
            return writes;
        }
    }

    static final class Trace {
        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 AdapterConfigurationException
            extends IllegalStateException {
        AdapterConfigurationException(String message) {
            super(message);
        }
    }

    static final class UnregisteredHandlerException
            extends IllegalArgumentException {
        UnregisteredHandlerException(String message) {
            super(message);
        }
    }
}