서블릿 생명 주기

package board.servlet;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

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.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.Test;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.web.server.servlet.context
        .ServletWebServerApplicationContext;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;

class EmbeddedServletLifecycleTest {
    private static final HttpClient CLIENT = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .version(HttpClient.Version.HTTP_1_1)
            .build();

    @Test
    void loadOnStartup은_첫_요청_전에_한_인스턴스를_초기화한다() {
        var probe = new LifecycleProbe();

        try (var server = RunningServer.start(probe)) {
            var registration = server.context()
                    .getServletContext()
                    .getServletRegistration("postCountServlet");

            assertNotNull(registration);
            assertAll(
                    () -> assertEquals(
                            Set.of("/raw/post-count"),
                            Set.copyOf(registration.getMappings())),
                    () -> assertEquals(1, probe.initCalls.get()),
                    () -> assertEquals(0, probe.getCalls.get()),
                    () -> assertEquals(1, probe.servletIdentities.size()),
                    () -> assertEquals(0, probe.destroyCalls.get()));
        }

        assertAll(
                () -> assertEquals(1, probe.destroyCalls.get()),
                () -> assertEquals(
                        List.of("init", "destroy"),
                        List.copyOf(probe.events)));
    }

    @Test
    void service는_GET을_doGet으로_보내고_HTTP1_1_POST는_405로_응답한다()
            throws Exception {
        var probe = new LifecycleProbe();

        try (var server = RunningServer.start(probe)) {
            var get = send(
                    server,
                    "GET",
                    "/raw/post-count?memberId=7");
            var post = send(server, "POST", "/raw/post-count");

            assertAll(
                    () -> assertEquals(200, get.statusCode()),
                    () -> assertEquals("7:70", get.body()),
                    () -> assertTrue(get.headers()
                            .firstValue("content-type")
                            .orElseThrow()
                            .startsWith("text/plain")),
                    () -> assertEquals(405, post.statusCode()),
                    () -> assertEquals(1, probe.getCalls.get()),
                    () -> assertEquals(1, probe.servletIdentities.size()));
        }
    }

    @Test
    void 같은_인스턴스가_두_GET을_동시에_처리해도_지역_값은_섞이지_않는다()
            throws Exception {
        var probe = new LifecycleProbe();

        try (var server = RunningServer.start(probe);
                var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            var first = executor.submit(() -> send(
                    server,
                    "GET",
                    "/raw/post-count?memberId=7&hold=true"));
            var second = executor.submit(() -> send(
                    server,
                    "GET",
                    "/raw/post-count?memberId=9&hold=true"));

            try {
                assertTrue(probe.concurrentEntries.await(5, SECONDS));
                assertAll(
                        () -> assertEquals(2, probe.activeCalls.get()),
                        () -> assertEquals(2, probe.maxActiveCalls.get()));
            } finally {
                probe.releaseConcurrentCalls.countDown();
            }

            var firstResponse = first.get(5, SECONDS);
            var secondResponse = second.get(5, SECONDS);

            assertAll(
                    () -> assertEquals(
                            Set.of("7:70", "9:90"),
                            Set.of(
                                    firstResponse.body(),
                                    secondResponse.body())),
                    () -> assertEquals(2, probe.requestIdentities.size()),
                    () -> assertEquals(2, probe.responseIdentities.size()),
                    () -> assertEquals(1, probe.servletIdentities.size()),
                    () -> assertEquals(0, probe.activeCalls.get()));
        }
    }

    @Test
    void context를_닫으면_마지막_service_뒤_destroy를_한_번_호출한다()
            throws Exception {
        var probe = new LifecycleProbe();
        HttpResponse<String> response;

        try (var server = RunningServer.start(probe)) {
            response = send(
                    server,
                    "GET",
                    "/raw/post-count?memberId=11");
        }

        assertAll(
                () -> assertEquals(200, response.statusCode()),
                () -> assertEquals(1, probe.destroyCalls.get()),
                () -> assertEquals(
                        List.of("init", "get:11", "destroy"),
                        List.copyOf(probe.events)));
    }

    private static HttpResponse<String> send(
            RunningServer server,
            String method,
            String path)
            throws IOException, InterruptedException {
        var request = HttpRequest.newBuilder(
                        URI.create(server.origin() + path))
                .timeout(Duration.ofSeconds(5))
                .method(method, HttpRequest.BodyPublishers.noBody())
                .build();
        return CLIENT.send(
                request,
                HttpResponse.BodyHandlers.ofString(UTF_8));
    }

    private record RunningServer(
            ServletWebServerApplicationContext context,
            String origin)
            implements AutoCloseable {
        static RunningServer start(LifecycleProbe probe) {
            var application = new SpringApplication(TestApplication.class);
            application.setWebApplicationType(WebApplicationType.SERVLET);
            application.setRegisterShutdownHook(false);
            application.setDefaultProperties(Map.of(
                    "server.address", "127.0.0.1",
                    "server.port", "0",
                    "spring.main.banner-mode", "off",
                    "logging.level.root", "OFF"));
            application.addInitializers(context -> context
                    .getBeanFactory()
                    .registerSingleton("lifecycleProbe", probe));

            var context = (ServletWebServerApplicationContext)
                    application.run();
            var origin = "http://127.0.0.1:"
                    + context.getWebServer().getPort();
            return new RunningServer(context, origin);
        }

        @Override
        public void close() {
            context.close();
        }
    }

    @SpringBootConfiguration(proxyBeanMethods = false)
    @EnableAutoConfiguration
    static class TestApplication {
        @Bean
        ServletRegistrationBean<PostCountServlet> postCountServlet(
                LifecycleProbe probe) {
            var servlet = new PostCountServlet(
                    probe,
                    memberId -> memberId * 10);
            var registration = new ServletRegistrationBean<>(
                    servlet,
                    "/raw/post-count");
            registration.setName("postCountServlet");
            registration.setLoadOnStartup(1);
            return registration;
        }
    }

    @FunctionalInterface
    interface PostQuery {
        long countByMember(long memberId);
    }

    static final class PostCountServlet extends HttpServlet {
        private final LifecycleProbe probe;
        private final PostQuery query;

        PostCountServlet(
                LifecycleProbe probe,
                PostQuery query) {
            this.probe = probe;
            this.query = query;
        }

        @Override
        public void init() {
            probe.initCalls.incrementAndGet();
            probe.servletIdentities.add(
                    System.identityHashCode(this));
            probe.events.add("init");
        }

        @Override
        protected void doGet(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException, ServletException {
            probe.getCalls.incrementAndGet();
            probe.servletIdentities.add(
                    System.identityHashCode(this));
            probe.requestIdentities.add(
                    System.identityHashCode(request));
            probe.responseIdentities.add(
                    System.identityHashCode(response));

            var rawMemberId = request.getParameter("memberId");
            final long memberId;
            try {
                memberId = Long.parseLong(rawMemberId);
            } catch (NumberFormatException exception) {
                response.sendError(
                        HttpServletResponse.SC_BAD_REQUEST,
                        "memberId must be an integer");
                return;
            }

            probe.events.add("get:" + memberId);
            var active = probe.activeCalls.incrementAndGet();
            probe.maxActiveCalls.accumulateAndGet(active, Math::max);

            try {
                if ("true".equals(request.getParameter("hold"))) {
                    probe.concurrentEntries.countDown();
                    if (!probe.releaseConcurrentCalls.await(5, SECONDS)) {
                        response.sendError(
                                HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                                "concurrency gate timed out");
                        return;
                    }
                }

                var count = query.countByMember(memberId);
                response.setStatus(HttpServletResponse.SC_OK);
                response.setContentType("text/plain");
                response.setCharacterEncoding(UTF_8);
                response.getWriter().write(memberId + ":" + count);
            } catch (InterruptedException exception) {
                Thread.currentThread().interrupt();
                throw new ServletException(
                        "request was interrupted",
                        exception);
            } finally {
                probe.activeCalls.decrementAndGet();
            }
        }

        @Override
        public void destroy() {
            probe.destroyCalls.incrementAndGet();
            probe.events.add("destroy");
        }
    }

    static final class LifecycleProbe {
        final AtomicInteger initCalls = new AtomicInteger();
        final AtomicInteger getCalls = new AtomicInteger();
        final AtomicInteger destroyCalls = new AtomicInteger();
        final AtomicInteger activeCalls = new AtomicInteger();
        final AtomicInteger maxActiveCalls = new AtomicInteger();
        final Set<Integer> servletIdentities =
                ConcurrentHashMap.newKeySet();
        final Set<Integer> requestIdentities =
                ConcurrentHashMap.newKeySet();
        final Set<Integer> responseIdentities =
                ConcurrentHashMap.newKeySet();
        final ConcurrentLinkedQueue<String> events =
                new ConcurrentLinkedQueue<>();
        final CountDownLatch concurrentEntries =
                new CountDownLatch(2);
        final CountDownLatch releaseConcurrentCalls =
                new CountDownLatch(1);
    }
}