HTTP 캐시와 조건부 요청

package board.web;

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.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;

import jakarta.servlet.http.HttpServletResponse;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.HashMap;
import java.util.HexFormat;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.http.ETag;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.WebRequest;

class HttpCacheContractTest {
    private static final String CACHE_POLICY =
            "private, no-cache";
    private static final String CSV_MEDIA_TYPE =
            "text/csv;charset=UTF-8";
    private static final MediaType CSV =
            MediaType.parseMediaType("text/csv");
    private static final long INITIAL_RAW_LAST_MODIFIED =
            Instant.parse("2030-01-15T00:00:00.987Z")
                    .toEpochMilli();
    private static final long INITIAL_LAST_MODIFIED =
            toHttpSecond(INITIAL_RAW_LAST_MODIFIED);
    private static final long UPDATED_RAW_LAST_MODIFIED =
            Instant.parse("2030-01-15T00:01:00.654Z")
                    .toEpochMilli();
    private static final String INITIAL_HTTP_DATE =
            "Tue, 15 Jan 2030 00:00:00 GMT";
    private static final String FUTURE_HTTP_DATE =
            "Tue, 15 Jan 2030 00:10:00 GMT";
    private static final byte[] JSON_V1 = (
                    "{\"id\":42,\"title\":\"HTTP cache\","
                            + "\"content\":\"조건부 요청을 정리합니다.\","
                            + "\"version\":7}\n")
            .getBytes(UTF_8);
    private static final byte[] CSV_V1 = (
                    "id,title,content,version\n"
                            + "42,HTTP cache,조건부 요청을 정리합니다.,7\n")
            .getBytes(UTF_8);
    private static final byte[] JSON_V2 = (
                    "{\"id\":42,\"title\":\"HTTP cache\","
                            + "\"content\":\"캐시 갱신을 정리합니다.\","
                            + "\"version\":8}\n")
            .getBytes(UTF_8);
    private static final byte[] CSV_V2 = (
                    "id,title,content,version\n"
                            + "42,HTTP cache,캐시 갱신을 정리합니다.,8\n")
            .getBytes(UTF_8);

    @Test
    void 첫_JSON_조회는_정확한_표현과_검증기를_200으로_보낸다()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON))
                .andReturn();
        var response = result.getResponse();

        assertAll(
                () -> assertEquals(
                        200, response.getStatus()),
                () -> assertEquals(
                        APPLICATION_JSON_VALUE,
                        response.getContentType()),
                () -> assertArrayEquals(
                        JSON_V1,
                        response.getContentAsByteArray()),
                () -> assertEquals(
                        strongEtag(JSON_V1),
                        response.getHeader(
                                HttpHeaders.ETAG)),
                () -> assertEquals(
                        CACHE_POLICY,
                        response.getHeader(
                                HttpHeaders.CACHE_CONTROL)),
                () -> assertEquals(
                        HttpHeaders.ACCEPT,
                        response.getHeader(
                                HttpHeaders.VARY)),
                () -> assertEquals(
                        INITIAL_LAST_MODIFIED,
                        response.getDateHeader(
                                HttpHeaders.LAST_MODIFIED)));
    }

    @Test
    void 정확한_ETag는_메타데이터를_유지한_빈_304를_만든다()
            throws Exception {
        var fixture = fixture();
        var etag = strongEtag(JSON_V1);

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        etag))
                .andReturn();
        var response = result.getResponse();

        assertAll(
                () -> assertEquals(
                        304, response.getStatus()),
                () -> assertEquals(
                        0,
                        response.getContentAsByteArray()
                                .length),
                () -> assertEquals(
                        etag,
                        response.getHeader(
                                HttpHeaders.ETAG)),
                () -> assertEquals(
                        CACHE_POLICY,
                        response.getHeader(
                                HttpHeaders.CACHE_CONTROL)),
                () -> assertEquals(
                        HttpHeaders.ACCEPT,
                        response.getHeader(
                                HttpHeaders.VARY)));
    }

    @Test
    void 약한_If_None_Match도_약한_비교로_304가_된다()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        "W/" + strongEtag(JSON_V1)))
                .andReturn();

        assertAll(
                () -> assertEquals(
                        304,
                        result.getResponse().getStatus()),
                () -> assertEquals(
                        0,
                        result.getResponse()
                                .getContentAsByteArray()
                                .length));
    }

    @Test
    void 쉼표_목록의_하나가_맞으면_304가_된다()
            throws Exception {
        var fixture = fixture();
        var list = "\"unrelated\", "
                + strongEtag(JSON_V1);

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        list))
                .andReturn();

        assertEquals(
                304, result.getResponse().getStatus());
    }

    @Test
    void 와일드카드는_존재하는_표현에_304가_된다()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        "*"))
                .andReturn();

        assertEquals(
                304, result.getResponse().getStatus());
    }

    @Test
    void 맞지_않는_ETag가_있으면_미래_IMS보다_우선해_200이다()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        "\"not-current\"")
                                .header(
                                        HttpHeaders.IF_MODIFIED_SINCE,
                                        FUTURE_HTTP_DATE))
                .andReturn();

        assertAll(
                () -> assertEquals(
                        200, result.getResponse().getStatus()),
                () -> assertArrayEquals(
                        JSON_V1,
                        result.getResponse()
                                .getContentAsByteArray()));
    }

    @Test
    void IMS만_보내면_초_정밀도로_304가_된다()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_MODIFIED_SINCE,
                                        INITIAL_HTTP_DATE))
                .andReturn();

        assertAll(
                () -> assertEquals(
                        304, result.getResponse().getStatus()),
                () -> assertEquals(
                        INITIAL_LAST_MODIFIED,
                        fixture.store()
                                .find(42L)
                                .lastModifiedMillis()),
                () -> assertEquals(
                        INITIAL_LAST_MODIFIED,
                        result.getResponse().getDateHeader(
                                HttpHeaders.LAST_MODIFIED)),
                () -> assertEquals(
                        0,
                        result.getResponse()
                                .getContentAsByteArray()
                                .length));
    }

    @Test
    void 변경_뒤_옛_ETag는_새_본문과_태그의_200을_받는다()
            throws Exception {
        var fixture = fixture();
        var oldEtag = strongEtag(JSON_V1);
        fixture.store().replace(
                42L,
                JSON_V2,
                CSV_V2,
                UPDATED_RAW_LAST_MODIFIED);

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        oldEtag))
                .andReturn();
        var response = result.getResponse();

        assertAll(
                () -> assertEquals(
                        200, response.getStatus()),
                () -> assertArrayEquals(
                        JSON_V2,
                        response.getContentAsByteArray()),
                () -> assertEquals(
                        strongEtag(JSON_V2),
                        response.getHeader(
                                HttpHeaders.ETAG)),
                () -> assertNotEquals(
                        oldEtag,
                        response.getHeader(
                                HttpHeaders.ETAG)));
    }

    @Test
    void JSON_ETag로_CSV를_조회하면_다른_표현의_200이다()
            throws Exception {
        var fixture = fixture();
        var jsonEtag = strongEtag(JSON_V1);

        var result = fixture.mvc().perform(
                        get("/api/posts/42")
                                .accept(CSV)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        jsonEtag))
                .andReturn();
        var response = result.getResponse();

        assertAll(
                () -> assertEquals(
                        200, response.getStatus()),
                () -> assertEquals(
                        CSV_MEDIA_TYPE,
                        response.getContentType()),
                () -> assertArrayEquals(
                        CSV_V1,
                        response.getContentAsByteArray()),
                () -> assertEquals(
                        strongEtag(CSV_V1),
                        response.getHeader(
                                HttpHeaders.ETAG)),
                () -> assertNotEquals(
                        jsonEtag,
                        response.getHeader(
                                HttpHeaders.ETAG)));
    }

    @Test
    void 없는_리소스는_조건부_헤더보다_먼저_404_no_store다()
            throws Exception {
        var fixture = fixture();

        var result = fixture.mvc().perform(
                        get("/api/posts/404")
                                .accept(APPLICATION_JSON)
                                .header(
                                        HttpHeaders.IF_NONE_MATCH,
                                        "*")
                                .header(
                                        HttpHeaders.IF_MODIFIED_SINCE,
                                        FUTURE_HTTP_DATE))
                .andReturn();
        var response = result.getResponse();

        assertAll(
                () -> assertEquals(
                        404, response.getStatus()),
                () -> assertEquals(
                        "no-store",
                        response.getHeader(
                                HttpHeaders.CACHE_CONTROL)),
                () -> assertNull(
                        response.getHeader(
                                HttpHeaders.ETAG)),
                () -> assertEquals(
                        0,
                        response.getContentAsByteArray()
                                .length));
    }

    private static Fixture fixture() {
        var store = new PostStore();
        var controller =
                new HttpCacheController(store);
        var mvc = MockMvcBuilders
                .standaloneSetup(controller)
                .build();
        return new Fixture(store, mvc);
    }

    private static boolean hasWildcardIfNoneMatch(
            WebRequest request) {
        var fieldValues = request.getHeaderValues(
                HttpHeaders.IF_NONE_MATCH);
        if (fieldValues == null) {
            return false;
        }
        for (var fieldValue : fieldValues) {
            if (ETag.parse(fieldValue).stream()
                    .anyMatch(ETag::isWildcard)) {
                return true;
            }
        }
        return false;
    }

    private static long toHttpSecond(long millis) {
        return Math.floorDiv(millis, 1_000L)
                * 1_000L;
    }

    private static String strongEtag(
            byte[] representation) {
        try {
            var digest = MessageDigest
                    .getInstance("SHA-256")
                    .digest(representation);
            return "\"" + HexFormat.of()
                    .formatHex(digest) + "\"";
        } catch (NoSuchAlgorithmException exception) {
            throw new IllegalStateException(
                    "SHA-256 must be available",
                    exception);
        }
    }

    @RestController
    @RequestMapping("/api/posts")
    static final class HttpCacheController {
        private final PostStore store;

        private HttpCacheController(
                PostStore store) {
            this.store = store;
        }

        @GetMapping(
                value = "/{id}",
                produces = APPLICATION_JSON_VALUE)
        byte[] json(
                @PathVariable("id") long id,
                WebRequest request,
                HttpServletResponse response) {
            return respond(
                    id,
                    Representation.JSON,
                    request,
                    response);
        }

        @GetMapping(
                value = "/{id}",
                produces = "text/csv")
        byte[] csv(
                @PathVariable("id") long id,
                WebRequest request,
                HttpServletResponse response) {
            return respond(
                    id,
                    Representation.CSV,
                    request,
                    response);
        }

        private byte[] respond(
                long id,
                Representation representation,
                WebRequest request,
                HttpServletResponse response) {
            var post = store.find(id);
            if (post == null) {
                response.setStatus(
                        HttpServletResponse.SC_NOT_FOUND);
                response.setHeader(
                        HttpHeaders.CACHE_CONTROL,
                        "no-store");
                return null;
            }

            var body = representation.select(post);
            var etag = strongEtag(body);
            var lastModifiedMillis =
                    post.lastModifiedMillis();

            response.setHeader(
                    HttpHeaders.ETAG, etag);
            response.setHeader(
                    HttpHeaders.CACHE_CONTROL,
                    CACHE_POLICY);
            response.setHeader(
                    HttpHeaders.VARY,
                    HttpHeaders.ACCEPT);
            response.setDateHeader(
                    HttpHeaders.LAST_MODIFIED,
                    lastModifiedMillis);

            if (hasWildcardIfNoneMatch(request)) {
                response.setStatus(
                        HttpServletResponse.SC_NOT_MODIFIED);
                return null;
            }
            if (request.checkNotModified(
                    etag, lastModifiedMillis)) {
                return null;
            }

            response.setContentType(
                    representation.contentType());
            response.setContentLength(body.length);
            return body;
        }
    }

    enum Representation {
        JSON(APPLICATION_JSON_VALUE),
        CSV(CSV_MEDIA_TYPE);

        private final String contentType;

        Representation(String contentType) {
            this.contentType = contentType;
        }

        private String contentType() {
            return contentType;
        }

        private byte[] select(StoredPost post) {
            return switch (this) {
                case JSON -> post.json().clone();
                case CSV -> post.csv().clone();
            };
        }
    }

    static final class PostStore {
        private final Map<Long, StoredPost> posts =
                new HashMap<>();

        private PostStore() {
            replace(
                    42L,
                    JSON_V1,
                    CSV_V1,
                    INITIAL_RAW_LAST_MODIFIED);
        }

        private StoredPost find(long id) {
            return posts.get(id);
        }

        private void replace(
                long id,
                byte[] json,
                byte[] csv,
                long lastModifiedMillis) {
            posts.put(
                    id,
                    new StoredPost(
                            json.clone(),
                            csv.clone(),
                            toHttpSecond(
                                    lastModifiedMillis)));
        }
    }

    record StoredPost(
            byte[] json,
            byte[] csv,
            long lastModifiedMillis) {}

    record Fixture(
            PostStore store,
            MockMvc mvc) {}
}