웹 서버·WAS·서블릿 컨테이너

package board.server;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

import jakarta.servlet.DispatcherType;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.boot.tomcat.TomcatWebServer;
import org.springframework.boot.web.server.servlet.context
        .ServletWebServerApplicationContext;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.core.Ordered;
import org.springframework.http.MediaType;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.resource.ResourceHttpRequestHandler;

@SpringBootTest(
        classes = EmbeddedServletBoundaryTest.TestApplication.class,
        webEnvironment = RANDOM_PORT,
        properties = {
            "server.address=127.0.0.1",
            "spring.main.banner-mode=off",
            "logging.level.root=OFF"
        })
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
@Execution(ExecutionMode.SAME_THREAD)
class EmbeddedServletBoundaryTest {
    private static final Path STATIC_ROOT = createStaticRoot();

    private final HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .build();

    @LocalServerPort
    int port;

    @Autowired
    ApplicationContext applicationContext;

    @Autowired
    ProbeState state;

    @DynamicPropertySource
    static void staticLocation(DynamicPropertyRegistry registry) {
        registry.add(
                "spring.web.resources.static-locations",
                () -> STATIC_ROOT.toUri().toString());
    }

    @BeforeEach
    void resetCounters() {
        state.reset();
    }

    @AfterAll
    static void removeStaticFixture() throws IOException {
        Files.deleteIfExists(STATIC_ROOT.resolve("boundary.txt"));
        Files.deleteIfExists(STATIC_ROOT);
    }

    @Test
    void Boot가_Tomcat과_DispatcherServlet을_random_port에_조립한다() {
        var context = assertInstanceOf(
                ServletWebServerApplicationContext.class,
                applicationContext);
        var server = assertInstanceOf(
                TomcatWebServer.class,
                context.getWebServer());
        var registration = context.getServletContext()
                .getServletRegistration("dispatcherServlet");

        assertNotNull(registration);
        assertAll(
                () -> assertTrue(port > 0),
                () -> assertEquals(port, server.getPort()),
                () -> assertEquals(
                        port,
                        server.getTomcat()
                                .getConnector()
                                .getLocalPort()),
                () -> assertInstanceOf(
                        DispatcherServlet.class,
                        applicationContext.getBean(
                                "dispatcherServlet")),
                () -> assertEquals(
                        Set.of("/"), registration.getMappings()),
                () -> assertEquals(
                        6,
                        context.getServletContext()
                                .getMajorVersion()),
                () -> assertEquals(
                        1,
                        context.getServletContext()
                                .getMinorVersion()));
    }

    @Test
    void 동적_probe는_loopback_Filter_DispatcherServlet_handler를_통과한다()
            throws Exception {
        var response = send("/boundary/dynamic");

        assertAll(
                () -> assertEquals(200, response.statusCode()),
                () -> assertEquals("dynamic-ok", response.body()),
                () -> assertTrue(contentType(response)
                        .startsWith(MediaType.TEXT_PLAIN_VALUE)),
                () -> assertEquals(
                        "REQUEST",
                        header(response, "X-Boundary-Filter")),
                () -> assertEquals(
                        Integer.toString(port),
                        header(response, "X-Boundary-Local-Port")),
                () -> assertEquals(
                        "handler-method",
                        header(response, "X-Boundary-Mvc-Handler")),
                () -> assertEquals(1, state.filterCalls.get()),
                () -> assertEquals(1, state.interceptorCalls.get()),
                () -> assertEquals(1, state.controllerCalls.get()));
    }

    @Test
    void 정적_probe는_loopback_Filter_DispatcherServlet_resource_handler를_통과한다()
            throws Exception {
        var response = send("/boundary.txt");

        assertAll(
                () -> assertEquals(200, response.statusCode()),
                () -> assertEquals("static-ok", response.body()),
                () -> assertTrue(contentType(response)
                        .startsWith(MediaType.TEXT_PLAIN_VALUE)),
                () -> assertEquals(
                        "REQUEST",
                        header(response, "X-Boundary-Filter")),
                () -> assertEquals(
                        Integer.toString(port),
                        header(response, "X-Boundary-Local-Port")),
                () -> assertEquals(
                        "resource",
                        header(response, "X-Boundary-Mvc-Handler")),
                () -> assertEquals(1, state.filterCalls.get()),
                () -> assertEquals(1, state.interceptorCalls.get()),
                () -> assertEquals(0, state.controllerCalls.get()));
    }

    @Test
    void 없는_경로는_404이고_ProbeController를_호출하지_않는다()
            throws Exception {
        var response = send("/boundary/missing");

        assertAll(
                () -> assertEquals(404, response.statusCode()),
                () -> assertEquals(1, state.filterCalls.get()),
                () -> assertEquals(0, state.controllerCalls.get()));
    }

    private HttpResponse<String> send(String path)
            throws IOException, InterruptedException {
        var request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "http://127.0.0.1:" + port + path))
                .timeout(Duration.ofSeconds(5))
                .GET()
                .build();
        return client.send(
                request,
                HttpResponse.BodyHandlers.ofString(UTF_8));
    }

    private static String header(
            HttpResponse<?> response, String name) {
        return response.headers()
                .firstValue(name)
                .orElse("");
    }

    private static String contentType(HttpResponse<?> response) {
        return header(response, "Content-Type");
    }

    private static Path createStaticRoot() {
        Path root = null;
        try {
            root = Files.createTempDirectory(
                    "embedded-servlet-boundary-");
            Files.writeString(
                    root.resolve("boundary.txt"),
                    "static-ok",
                    UTF_8);
            return root;
        } catch (IOException exception) {
            if (root != null) {
                try {
                    Files.deleteIfExists(
                            root.resolve("boundary.txt"));
                    Files.deleteIfExists(root);
                } catch (IOException cleanupException) {
                    exception.addSuppressed(cleanupException);
                }
            }
            throw new UncheckedIOException(exception);
        }
    }

    @SpringBootConfiguration
    @EnableAutoConfiguration
    static class TestApplication {
        @Bean
        ProbeState probeState() {
            return new ProbeState();
        }

        @Bean
        ProbeController probeController(ProbeState state) {
            return new ProbeController(state);
        }

        @Bean
        FilterRegistrationBean<BoundaryFilter> boundaryFilter(
                ProbeState state) {
            var registration = new FilterRegistrationBean<>(
                    new BoundaryFilter(state));
            registration.setName("boundaryFilter");
            registration.setDispatcherTypes(DispatcherType.REQUEST);
            registration.addUrlPatterns("/*");
            registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
            return registration;
        }

        @Bean
        WebMvcConfigurer boundaryMvcConfigurer(ProbeState state) {
            return new WebMvcConfigurer() {
                @Override
                public void addInterceptors(
                        InterceptorRegistry registry) {
                    registry.addInterceptor(
                            new BoundaryInterceptor(state));
                }
            };
        }
    }

    static final class ProbeState {
        private final AtomicInteger filterCalls =
                new AtomicInteger();
        private final AtomicInteger interceptorCalls =
                new AtomicInteger();
        private final AtomicInteger controllerCalls =
                new AtomicInteger();

        void reset() {
            filterCalls.set(0);
            interceptorCalls.set(0);
            controllerCalls.set(0);
        }
    }

    @RestController
    static final class ProbeController {
        private final ProbeState state;

        ProbeController(ProbeState state) {
            this.state = state;
        }

        @GetMapping(
                value = "/boundary/dynamic",
                produces = MediaType.TEXT_PLAIN_VALUE)
        String dynamic() {
            state.controllerCalls.incrementAndGet();
            return "dynamic-ok";
        }
    }

    static final class BoundaryFilter
            extends OncePerRequestFilter {
        private final ProbeState state;

        BoundaryFilter(ProbeState state) {
            this.state = state;
        }

        @Override
        protected void doFilterInternal(
                HttpServletRequest request,
                HttpServletResponse response,
                FilterChain chain)
                throws ServletException, IOException {
            state.filterCalls.incrementAndGet();
            response.setHeader(
                    "X-Boundary-Filter",
                    request.getDispatcherType().name());
            response.setHeader(
                    "X-Boundary-Local-Port",
                    Integer.toString(request.getLocalPort()));
            chain.doFilter(request, response);
        }
    }

    static final class BoundaryInterceptor
            implements HandlerInterceptor {
        private final ProbeState state;

        BoundaryInterceptor(ProbeState state) {
            this.state = state;
        }

        @Override
        public boolean preHandle(
                HttpServletRequest request,
                HttpServletResponse response,
                Object handler) {
            state.interceptorCalls.incrementAndGet();
            String kind;
            if (handler instanceof HandlerMethod) {
                kind = "handler-method";
            } else if (handler
                    instanceof ResourceHttpRequestHandler) {
                kind = "resource";
            } else {
                kind = handler.getClass().getSimpleName();
            }
            response.setHeader("X-Boundary-Mvc-Handler", kind);
            return true;
        }
    }
}