HTTP 메시지 구조

POST /api/posts HTTP/1.1
Host: board.example
Content-Type: application/json
Accept: application/json
Content-Length: 97

{"title":"HTTP","content":"HTTP 메시지 구조를 정리합니다.","publishedOn":"2026-07-13"}

package board.http;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertEquals;

import java.net.URI;
import java.net.http.HttpRequest;
import org.junit.jupiter.api.Test;

final class HttpRequestShapeTest {
    private static final String JSON =
            "{\"title\":\"HTTP\",\"content\":\"HTTP 메시지 구조를 정리합니다.\","
                    + "\"publishedOn\":\"2026-07-13\"}";

    @Test
    void 메서드_uri_필드와_utf8_콘텐츠_길이를_분리한다() {
        HttpRequest.BodyPublisher publisher =
                HttpRequest.BodyPublishers.ofString(JSON, UTF_8);
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://board.example/api/posts"))
                .header("Content-Type", "application/json")
                .header("Accept", "application/json")
                .POST(publisher)
                .build();

        assertEquals(97, JSON.getBytes(UTF_8).length);
        assertEquals(97L, publisher.contentLength());
        assertEquals(97L,
                request.bodyPublisher().orElseThrow().contentLength());
        assertEquals("POST", request.method());
        assertEquals("/api/posts", request.uri().getPath());
        assertEquals("application/json",
                request.headers()
                        .firstValue("content-type")
                        .orElseThrow());
    }
}

HTTP/1.1 201 Created
Content-Type: application/json
Location: /api/posts/42
Content-Length: 105

{"id":42,"title":"HTTP","content":"HTTP 메시지 구조를 정리합니다.","publishedOn":"2026-07-13"}

package board.web;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.validation.Valid;
import java.net.URI;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ProblemDetail;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RestControllerAdvice;

final class PostMessageContractTest {
    private static final String VALID_JSON =
            "{\"title\":\"HTTP\",\"content\":\"HTTP 메시지 구조를 정리합니다.\","
                    + "\"publishedOn\":\"2026-07-13\"}";
    private static final String CREATED_JSON =
            "{\"id\":42,\"title\":\"HTTP\",\"content\":"
                    + "\"HTTP 메시지 구조를 정리합니다.\","
                    + "\"publishedOn\":\"2026-07-13\"}";

    private AtomicInteger invocations;
    private ObjectMapper objectMapper;
    private MockMvc mockMvc;

    @BeforeEach
    void setUp() {
        invocations = new AtomicInteger();
        objectMapper = Jackson2ObjectMapperBuilder.json().build();
        mockMvc = MockMvcBuilders
                .standaloneSetup(new RegistrationController(invocations))
                .setControllerAdvice(new ApiExceptionHandler())
                .setValidator(new CreatePostValidator())
                .setMessageConverters(
                        new MappingJackson2HttpMessageConverter(
                                objectMapper))
                .build();
    }

    @Test
    void 올바른_json은_201_location과_json_표현을_반환한다()
            throws Exception {
        MvcResult result = perform(
                VALID_JSON,
                MediaType.APPLICATION_JSON,
                MediaType.APPLICATION_JSON);

        assertEquals(201, result.getResponse().getStatus());
        assertEquals("/api/posts/42",
                result.getResponse().getHeader(HttpHeaders.LOCATION));
        assertCompatible(
                MediaType.APPLICATION_JSON,
                result.getResponse().getContentType());
        byte[] content = result.getResponse().getContentAsByteArray();
        assertEquals(105, content.length);
        assertEquals(CREATED_JSON, new String(content, UTF_8));
        JsonNode body = objectMapper.readTree(content);
        assertEquals(42L, body.path("id").longValue());
        assertEquals("HTTP", body.path("title").textValue());
        assertEquals(1, invocations.get());
    }

    @Test
    void text_plain은_415이고_controller를_호출하지_않는다()
            throws Exception {
        MvcResult result = perform(
                VALID_JSON,
                MediaType.TEXT_PLAIN,
                MediaType.APPLICATION_JSON);

        assertEquals(415, result.getResponse().getStatus());
        assertEquals(0, invocations.get());
    }

    @Test
    void 깨진_json은_400이고_controller를_호출하지_않는다()
            throws Exception {
        MvcResult result = perform(
                "{\"title\":\"HTTP\"",
                MediaType.APPLICATION_JSON,
                MediaType.APPLICATION_JSON);

        assertEquals(400, result.getResponse().getStatus());
        assertEquals(0, invocations.get());
    }

    @Test
    void validator가_거부한_값은_400이고_controller를_호출하지_않는다()
            throws Exception {
        String blankTitle =
                "{\"title\":\"  \",\"content\":\"본문\","
                        + "\"publishedOn\":\"2026-07-13\"}";

        MvcResult result = perform(
                blankTitle,
                MediaType.APPLICATION_JSON,
                MediaType.APPLICATION_JSON);

        assertEquals(400, result.getResponse().getStatus());
        assertEquals(0, invocations.get());
    }

    @Test
    void 업무_중복은_409와_안정적인_problem_code를_반환한다()
            throws Exception {
        String duplicate =
                "{\"title\":\"duplicate\",\"content\":\"본문\","
                        + "\"publishedOn\":\"2026-07-13\"}";

        MvcResult result = perform(
                duplicate,
                MediaType.APPLICATION_JSON,
                MediaType.ALL);

        assertEquals(409, result.getResponse().getStatus());
        assertCompatible(
                MediaType.APPLICATION_PROBLEM_JSON,
                result.getResponse().getContentType());
        JsonNode body = readBody(result);
        assertEquals(409, body.path("status").intValue());
        assertEquals("POST_ALREADY_EXISTS",
                body.path("code").textValue());
        assertEquals(1, invocations.get());
    }

    @Test
    void produces와_맞지_않는_accept는_매핑에서_406이다()
            throws Exception {
        MvcResult result = perform(
                VALID_JSON,
                MediaType.APPLICATION_JSON,
                MediaType.APPLICATION_XML);

        assertEquals(406, result.getResponse().getStatus());
        assertEquals(0, invocations.get());
    }

    private MvcResult perform(
            String json,
            MediaType contentType,
            MediaType accept) throws Exception {
        return mockMvc.perform(post("/api/posts")
                        .contentType(contentType)
                        .accept(accept)
                        .content(json))
                .andReturn();
    }

    private JsonNode readBody(MvcResult result) throws Exception {
        return objectMapper.readTree(
                result.getResponse().getContentAsByteArray());
    }

    private static void assertCompatible(
            MediaType expected,
            String actual) {
        assertTrue(actual != null);
        assertTrue(expected.isCompatibleWith(
                MediaType.parseMediaType(actual)));
    }

    record CreatePostRequest(
            String title,
            String content,
            String publishedOn) {
    }

    record PostResponse(
            long id,
            String title,
            String content,
            String publishedOn) {
    }

    @RestController
    static final class RegistrationController {
        private final AtomicInteger invocations;

        RegistrationController(AtomicInteger invocations) {
            this.invocations = invocations;
        }

        @PostMapping(
                path = "/api/posts",
                consumes = MediaType.APPLICATION_JSON_VALUE,
                produces = MediaType.APPLICATION_JSON_VALUE)
        ResponseEntity<PostResponse> register(
                @Valid @RequestBody CreatePostRequest request) {
            invocations.incrementAndGet();
            if ("duplicate".equals(request.title())) {
                throw new DuplicatePostException();
            }

            PostResponse response = new PostResponse(
                    42L,
                    request.title(),
                    request.content(),
                    request.publishedOn());
            return ResponseEntity
                    .created(URI.create("/api/posts/42"))
                    .body(response);
        }
    }

    static final class CreatePostValidator implements Validator {
        @Override
        public boolean supports(Class<?> candidate) {
            return CreatePostRequest.class.isAssignableFrom(candidate);
        }

        @Override
        public void validate(Object target, Errors errors) {
            CreatePostRequest request = (CreatePostRequest) target;
            if (request.title() == null
                    || request.title().isBlank()) {
                errors.rejectValue("title", "title.required");
            }
            if (request.content() == null
                    || request.content().isBlank()) {
                errors.rejectValue("content", "content.required");
            }
        }
    }

    static final class DuplicatePostException
            extends RuntimeException {
    }

    @RestControllerAdvice
    static final class ApiExceptionHandler {
        @ExceptionHandler(DuplicatePostException.class)
        ResponseEntity<ProblemDetail> handleDuplicate() {
            ProblemDetail problem = ProblemDetail.forStatusAndDetail(
                    HttpStatus.CONFLICT,
                    "같은 제목의 게시글이 이미 있습니다.");
            problem.setTitle("Post conflict");
            problem.setProperty(
                    "code",
                    "POST_ALREADY_EXISTS");
            return ResponseEntity
                    .status(HttpStatus.CONFLICT)
                    .contentType(MediaType.APPLICATION_PROBLEM_JSON)
                    .body(problem);
        }
    }
}