서블릿 응답 출력

package board.servlet;

import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static java.nio.charset.StandardCharsets.UTF_8;
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.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
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.Map;
import java.util.concurrent.atomic.AtomicReference;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
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.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.http.MediaType;
import org.springframework.web.util.ContentCachingResponseWrapper;
import org.springframework.web.util.HtmlUtils;
import tools.jackson.databind.json.JsonMapper;

class EmbeddedServletResponseOutputTest {
    private static final HttpClient CLIENT = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .followRedirects(HttpClient.Redirect.NEVER)
            .version(HttpClient.Version.HTTP_1_1)
            .build();
    private static final String TEXT_BODY = "응답 UTF-8: 세 글자";
    private static final String JSON_TITLE = "HTTP \"응답\"\n\\끝";
    private static final byte[] CACHED_BODY =
            "cache-body:응답".getBytes(UTF_8);

    @Test
    void 인코딩은_writer보다_먼저_정하고_길이는_문자수가_아닌_바이트수다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var utf8 = send(server, "GET", "/raw/response/text");
            var late = send(server, "GET", "/raw/response/late-charset");

            assertAll(
                    () -> assertEquals(200, utf8.statusCode()),
                    () -> assertArrayEquals(
                            TEXT_BODY.getBytes(UTF_8), utf8.body()),
                    () -> assertEquals(
                            UTF_8,
                            mediaType(utf8).getCharset()),
                    () -> assertEquals(
                            TEXT_BODY.getBytes(UTF_8).length,
                            contentLength(utf8)),
                    () -> assertNotEquals(
                            TEXT_BODY.length(), contentLength(utf8)),
                    () -> assertEquals("metadata-before-writer", header(
                            utf8, "X-Phase")),
                    () -> assertEquals(ISO_8859_1, mediaType(late).getCharset()),
                    () -> assertArrayEquals(
                            "café".getBytes(ISO_8859_1), late.body()));
        }
    }

    @Test
    void writer와_outputStream은_상호_배타적이고_reset만_선택을_되돌린다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var writerFirst = send(
                    server, "GET", "/raw/response/writer-first");
            var streamFirst = send(
                    server, "GET", "/raw/response/stream-first");
            var resetSwitch = send(
                    server, "GET", "/raw/response/reset-switch");

            assertAll(
                    () -> assertEquals(
                            "writer->stream:IllegalStateException",
                            text(writerFirst, UTF_8)),
                    () -> assertEquals(
                            "stream->writer:IllegalStateException",
                            text(streamFirst, UTF_8)),
                    () -> assertEquals(200, resetSwitch.statusCode()),
                    () -> assertEquals(
                            "kept:응답", text(resetSwitch, UTF_8)),
                    () -> assertFalse(
                            text(resetSwitch, UTF_8).contains("discarded")));
        }
    }

    @Test
    void resetBuffer와_flushBuffer는_커밋_전후를_구분한다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var response = send(server, "GET", "/raw/response/buffer");
            var observation = server.probe().buffer.get();

            assertAll(
                    () -> assertEquals(200, response.statusCode()),
                    () -> assertEquals("kept", text(response, UTF_8)),
                    () -> assertFalse(observation.committedBeforeFlush()),
                    () -> assertTrue(observation.committedAfterFlush()),
                    () -> assertTrue(observation.resizeAfterWriteRejected()),
                    () -> assertTrue(observation.resetAfterCommitRejected()),
                    () -> assertTrue(observation.errorAfterCommitRejected()),
                    () -> assertEquals(null, response.headers()
                            .firstValue("X-Too-Late").orElse(null)));
        }
    }

    @Test
    void sendError는_커밋_전_버퍼를_비우지만_커밋_뒤에는_오류를_대체하지_못한다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var delegated = send(
                    server, "GET", "/raw/response/send-error");
            var explicit = send(
                    server, "GET", "/raw/response/set-status-error");
            var committed = send(
                    server, "GET", "/raw/response/committed-error");

            assertAll(
                    () -> assertEquals(409, delegated.statusCode()),
                    () -> assertFalse(text(delegated, UTF_8)
                            .contains("STALE-BODY")),
                    () -> assertEquals(409, explicit.statusCode()),
                    () -> assertEquals(
                            "application/problem+json",
                            mediaType(explicit).toString()),
                    () -> assertEquals(
                            "{\"status\":409}", text(explicit, UTF_8)),
                    () -> assertEquals(200, committed.statusCode()),
                    () -> assertEquals("partial", text(committed, UTF_8)),
                    () -> assertTrue(
                            server.probe().committedSendErrorRejected.get()));
        }
    }

    @Test
    void Boot_JsonMapper와_HTML_텍스트_인코더가_표현을_소유한다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var json = send(server, "GET", "/raw/response/json");
            var html = send(server, "GET", "/raw/response/html");
            var tree = server.jsonMapper().readTree(json.body());

            assertAll(
                    () -> assertSame(
                            server.jsonMapper(), server.probe().jsonMapper.get()),
                    () -> assertEquals(200, json.statusCode()),
                    () -> assertEquals(
                            "application/json", mediaType(json).toString()),
                    () -> assertTrue(mediaType(json).getParameters().isEmpty()),
                    () -> assertEquals(JSON_TITLE,
                            tree.get("title").asString()),
                    () -> assertEquals(42, tree.get("id").asInt()),
                    () -> assertFalse(tree.has("internalSecret")),
                    () -> assertEquals(
                            json.body().length, contentLength(json)),
                    () -> assertEquals(200, html.statusCode()),
                    () -> assertTrue(text(html, UTF_8)
                            .contains("<script>")),
                    () -> assertTrue(text(html, UTF_8).contains("&응답")),
                    () -> assertFalse(text(html, UTF_8).contains("<script>")));
        }
    }

    @Test
    void HEAD는_대응_표현_길이를_보내고_204와_304는_wire_본문이_없다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var get = send(server, "GET", "/raw/response/resource");
            var head = send(server, "HEAD", "/raw/response/resource");
            var noContent = send(
                    server, "GET", "/raw/response/no-content");
            var notModified = send(
                    server, "GET", "/raw/response/not-modified");

            assertAll(
                    () -> assertEquals(200, get.statusCode()),
                    () -> assertTrue(get.body().length > 0),
                    () -> assertEquals(get.body().length, contentLength(get)),
                    () -> assertEquals(200, head.statusCode()),
                    () -> assertEquals(0, head.body().length),
                    () -> assertEquals(get.body().length, contentLength(head)),
                    () -> assertEquals(204, noContent.statusCode()),
                    () -> assertEquals(0, noContent.body().length),
                    () -> assertFalse(noContent.headers()
                            .firstValue("Content-Length").isPresent()),
                    () -> assertEquals(304, notModified.statusCode()),
                    () -> assertEquals(0, notModified.body().length),
                    () -> assertOptionalContentLengthEquals(
                            notModified, get.body().length),
                    () -> assertEquals("\"post-42-v1\"", header(
                            notModified, "ETag")));
        }
    }

    @Test
    void ContentCachingResponseWrapper는_복사하기_전까지_수동_캐시다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var response = send(server, "GET", "/raw/response/cached");
            var observation = server.probe().cache.get();

            assertAll(
                    () -> assertEquals(200, response.statusCode()),
                    () -> assertArrayEquals(CACHED_BODY, response.body()),
                    () -> assertFalse(observation.committedAfterWrapperFlush()),
                    () -> assertArrayEquals(
                            CACHED_BODY, observation.cachedBeforeCopy()),
                    () -> assertArrayEquals(
                            observation.cachedBeforeCopy(), response.body()));
        }
    }

    private static HttpResponse<byte[]> 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.ofByteArray());
    }

    private static String text(
            HttpResponse<byte[]> response,
            java.nio.charset.Charset charset) {
        return new String(response.body(), charset);
    }

    private static String header(
            HttpResponse<byte[]> response,
            String name) {
        return response.headers().firstValue(name).orElseThrow();
    }

    private static long contentLength(HttpResponse<byte[]> response) {
        return Long.parseLong(header(response, "Content-Length"));
    }

    private static void assertOptionalContentLengthEquals(
            HttpResponse<byte[]> response,
            long expected) {
        response.headers()
                .firstValue("Content-Length")
                .ifPresent(value -> assertEquals(
                        expected, Long.parseLong(value)));
    }

    private static MediaType mediaType(HttpResponse<byte[]> response) {
        return MediaType.parseMediaType(header(response, "Content-Type"));
    }

    private record RunningServer(
            ServletWebServerApplicationContext context,
            String origin,
            ResponseProbe probe,
            JsonMapper jsonMapper)
            implements AutoCloseable {
        static RunningServer start() {
            var probe = new ResponseProbe();
            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("responseProbe", probe));

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

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

    @SpringBootConfiguration(proxyBeanMethods = false)
    @EnableAutoConfiguration
    static class TestApplication {
        @Bean
        ServletRegistrationBean<ResponseOutputServlet> responseOutputServlet(
                JsonMapper jsonMapper,
                ResponseProbe probe) {
            var registration = new ServletRegistrationBean<>(
                    new ResponseOutputServlet(jsonMapper, probe),
                    "/raw/response/*");
            registration.setName("responseOutputServlet");
            return registration;
        }

        @Bean
        FilterRegistrationBean<CopyingCacheFilter> copyingCacheFilter(
                ResponseProbe probe) {
            var registration = new FilterRegistrationBean<>(
                    new CopyingCacheFilter(probe));
            registration.setName("copyingCacheFilter");
            registration.addUrlPatterns("/raw/response/cached");
            registration.setOrder(1);
            return registration;
        }
    }

    static final class ResponseOutputServlet extends HttpServlet {
        private static final byte[] RESOURCE_BODY =
                "resource:응답".getBytes(UTF_8);
        private static final String HTML_INPUT =
                "<script>alert(\"x\")</script>&응답";
        private final JsonMapper jsonMapper;
        private final ResponseProbe probe;

        ResponseOutputServlet(JsonMapper jsonMapper, ResponseProbe probe) {
            this.jsonMapper = jsonMapper;
            this.probe = probe;
            probe.jsonMapper.set(jsonMapper);
        }

        @Override
        protected void doGet(
                HttpServletRequest request,
                HttpServletResponse response)
                throws IOException {
            switch (request.getRequestURI()) {
                case "/raw/response/text" -> writeText(response);
                case "/raw/response/late-charset" -> lateCharset(response);
                case "/raw/response/writer-first" -> writerFirst(response);
                case "/raw/response/stream-first" -> streamFirst(response);
                case "/raw/response/reset-switch" -> resetSwitch(response);
                case "/raw/response/buffer" -> buffer(response);
                case "/raw/response/send-error" -> sendError(response);
                case "/raw/response/set-status-error" ->
                        setStatusError(response);
                case "/raw/response/committed-error" ->
                        committedError(response);
                case "/raw/response/json" -> writeJson(response);
                case "/raw/response/html" -> writeHtml(response);
                case "/raw/response/resource" -> resource(response);
                case "/raw/response/no-content" -> noContent(response);
                case "/raw/response/not-modified" -> notModified(response);
                case "/raw/response/cached" -> cached(response);
                default -> response.sendError(404);
            }
        }

        private static void writeText(HttpServletResponse response)
                throws IOException {
            var bytes = TEXT_BODY.getBytes(UTF_8);
            response.setStatus(HttpServletResponse.SC_OK);
            response.setCharacterEncoding(UTF_8.name());
            response.setContentType("text/plain");
            response.setContentLength(bytes.length);
            response.setHeader("X-Phase", "metadata-before-writer");
            response.getWriter().write(TEXT_BODY);
        }

        private static void lateCharset(HttpServletResponse response)
                throws IOException {
            response.setContentType("text/plain");
            var writer = response.getWriter();
            response.setCharacterEncoding(UTF_8.name());
            writer.write("café");
        }

        private static void writerFirst(HttpServletResponse response)
                throws IOException {
            prepareUtf8Text(response);
            var writer = response.getWriter();
            try {
                response.getOutputStream();
                writer.write("unexpected");
            } catch (IllegalStateException expected) {
                writer.write("writer->stream:IllegalStateException");
            }
        }

        private static void streamFirst(HttpServletResponse response)
                throws IOException {
            prepareUtf8Text(response);
            var output = response.getOutputStream();
            try {
                response.getWriter();
                output.write("unexpected".getBytes(UTF_8));
            } catch (IllegalStateException expected) {
                output.write(
                        "stream->writer:IllegalStateException".getBytes(UTF_8));
            }
        }

        private static void resetSwitch(HttpServletResponse response)
                throws IOException {
            prepareUtf8Text(response);
            response.getWriter().write("discarded");
            response.reset();
            response.setStatus(HttpServletResponse.SC_OK);
            response.setContentType("text/plain;charset=UTF-8");
            response.getOutputStream().write("kept:응답".getBytes(UTF_8));
        }

        private void buffer(HttpServletResponse response) throws IOException {
            response.setBufferSize(64);
            prepareUtf8Text(response);
            var writer = response.getWriter();
            writer.write("discarded");
            var resizeRejected = false;
            try {
                response.setBufferSize(128);
            } catch (IllegalStateException expected) {
                resizeRejected = true;
            }
            var beforeFlush = response.isCommitted();
            response.resetBuffer();
            writer.write("kept");
            response.flushBuffer();
            var afterFlush = response.isCommitted();
            response.setStatus(HttpServletResponse.SC_CREATED);
            response.setHeader("X-Too-Late", "ignored");
            var resetRejected = false;
            try {
                response.resetBuffer();
            } catch (IllegalStateException expected) {
                resetRejected = true;
            }
            var errorRejected = false;
            try {
                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            } catch (IllegalStateException expected) {
                errorRejected = true;
            }
            probe.buffer.set(new BufferObservation(
                    beforeFlush,
                    afterFlush,
                    resizeRejected,
                    resetRejected,
                    errorRejected));
        }

        private static void sendError(HttpServletResponse response)
                throws IOException {
            response.getOutputStream().write("STALE-BODY".getBytes(UTF_8));
            response.sendError(HttpServletResponse.SC_CONFLICT, "conflict");
        }

        private static void setStatusError(HttpServletResponse response)
                throws IOException {
            var body = "{\"status\":409}".getBytes(UTF_8);
            response.setStatus(HttpServletResponse.SC_CONFLICT);
            response.setContentType("application/problem+json");
            response.setContentLength(body.length);
            response.getOutputStream().write(body);
        }

        private void committedError(HttpServletResponse response)
                throws IOException {
            response.setStatus(HttpServletResponse.SC_OK);
            response.getOutputStream().write("partial".getBytes(UTF_8));
            response.flushBuffer();
            try {
                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                probe.committedSendErrorRejected.set(false);
            } catch (IllegalStateException expected) {
                probe.committedSendErrorRejected.set(true);
            }
        }

        private void writeJson(HttpServletResponse response)
                throws IOException {
            var post = new DomainPost(42, JSON_TITLE, "server-only");
            var body = jsonMapper.writeValueAsBytes(PostResponse.from(post));
            response.setStatus(HttpServletResponse.SC_OK);
            response.setContentType("application/json");
            response.setContentLength(body.length);
            response.getOutputStream().write(body);
        }

        private static void writeHtml(HttpServletResponse response)
                throws IOException {
            var body = ("<!doctype html><h1>"
                            + HtmlUtils.htmlEscape(HTML_INPUT)
                            + "</h1>")
                    .getBytes(UTF_8);
            response.setStatus(HttpServletResponse.SC_OK);
            response.setContentType("text/html;charset=UTF-8");
            response.setContentLength(body.length);
            response.getOutputStream().write(body);
        }

        private static void resource(HttpServletResponse response)
                throws IOException {
            response.setStatus(HttpServletResponse.SC_OK);
            response.setContentType("text/plain;charset=UTF-8");
            response.setContentLength(RESOURCE_BODY.length);
            response.setHeader("ETag", "\"post-42-v1\"");
            response.getOutputStream().write(RESOURCE_BODY);
        }

        private static void noContent(HttpServletResponse response) {
            response.setStatus(HttpServletResponse.SC_NO_CONTENT);
        }

        private static void notModified(HttpServletResponse response) {
            response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            response.setHeader("ETag", "\"post-42-v1\"");
            response.setContentLength(RESOURCE_BODY.length);
        }

        private static void cached(HttpServletResponse response)
                throws IOException {
            response.setStatus(HttpServletResponse.SC_OK);
            response.setContentType("application/octet-stream");
            response.setContentLength(CACHED_BODY.length);
            response.getOutputStream().write(CACHED_BODY);
        }

        private static void prepareUtf8Text(HttpServletResponse response) {
            response.setStatus(HttpServletResponse.SC_OK);
            response.setCharacterEncoding(UTF_8.name());
            response.setContentType("text/plain");
        }
    }

    static final class CopyingCacheFilter implements Filter {
        private final ResponseProbe probe;

        CopyingCacheFilter(ResponseProbe probe) {
            this.probe = probe;
        }

        @Override
        public void doFilter(
                ServletRequest request,
                ServletResponse response,
                FilterChain chain)
                throws IOException, ServletException {
            var httpResponse = (HttpServletResponse) response;
            var wrapper = new ContentCachingResponseWrapper(httpResponse);
            chain.doFilter(request, wrapper);
            wrapper.flushBuffer();
            var committedAfterWrapperFlush = httpResponse.isCommitted();
            var cachedBeforeCopy = wrapper.getContentAsByteArray().clone();
            probe.cache.set(new CacheObservation(
                    committedAfterWrapperFlush, cachedBeforeCopy));
            wrapper.copyBodyToResponse();
        }
    }

    static final class ResponseProbe {
        final AtomicReference<BufferObservation> buffer =
                new AtomicReference<>();
        final AtomicReference<Boolean> committedSendErrorRejected =
                new AtomicReference<>(false);
        final AtomicReference<JsonMapper> jsonMapper =
                new AtomicReference<>();
        final AtomicReference<CacheObservation> cache =
                new AtomicReference<>();
    }

    private record BufferObservation(
            boolean committedBeforeFlush,
            boolean committedAfterFlush,
            boolean resizeAfterWriteRejected,
            boolean resetAfterCommitRejected,
            boolean errorAfterCommitRejected) {}

    private record CacheObservation(
            boolean committedAfterWrapperFlush,
            byte[] cachedBeforeCopy) {}

    private record DomainPost(
            long id,
            String title,
            String internalSecret) {}

    private record PostResponse(long id, String title) {
        static PostResponse from(DomainPost post) {
            return new PostResponse(post.id(), post.title());
        }
    }
}