HTTP 메시지 변환기

rootProject.name = 'mvc-boundary-contracts'

plugins { id 'java' }

java { toolchain { languageVersion = JavaLanguageVersion.of(25) } }

repositories { mavenCentral() }

dependencies {
    implementation platform('org.springframework.boot:spring-boot-dependencies:4.1.2')
    implementation 'org.springframework.boot:spring-boot-starter-webmvc'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    testImplementation platform('org.springframework.boot:spring-boot-dependencies:4.1.2')
    testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.release = 25
    options.compilerArgs += ['-parameters']
}

tasks.named('test') { useJUnitPlatform() }

package board.converter;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Import;

@SpringBootConfiguration(proxyBeanMethods = false)
@EnableAutoConfiguration
@Import({
    ConverterProbe.class,
    FixedPostQuery.class,
    NegotiatedPostController.class,
    WebConverterConfig.class
})
public class ConverterTestApplication {
}

package board.converter;

import java.util.Objects;

public record PostResponse(long id, String title, String content) {
    public PostResponse {
        if (id < 1) {
            throw new IllegalArgumentException("id must be positive");
        }
        Objects.requireNonNull(title, "title");
        Objects.requireNonNull(content, "content");
    }
}

package board.converter;

@FunctionalInterface
public interface PostQuery {
    PostResponse required(long id);
}

package board.converter;

public final class FixedPostQuery implements PostQuery {
    private static final PostResponse POST = new PostResponse(
            42L,
            "JSON, CSV",
            "같은 게시글을 CSV로 표현");

    @Override
    public PostResponse required(long id) {
        if (id != POST.id()) {
            throw new IllegalArgumentException("unknown post: " + id);
        }
        return POST;
    }
}

package board.converter;

import java.util.concurrent.atomic.AtomicInteger;

public final class ConverterProbe {
    private final AtomicInteger controllerCalls = new AtomicInteger();

    void controllerEntered() {
        controllerCalls.incrementAndGet();
    }

    public int controllerCalls() {
        return controllerCalls.get();
    }

    public void reset() {
        controllerCalls.set(0);
    }
}

package board.converter;

import java.util.Objects;

public final class Csv {
    private Csv() {
    }

    static String field(String value) {
        Objects.requireNonNull(value, "value");
        var quoted = value.replace("\"", "\"\"");
        var needsQuotes = value.indexOf(',') >= 0
                || value.indexOf('\"') >= 0
                || value.indexOf('\r') >= 0
                || value.indexOf('\n') >= 0;
        return needsQuotes ? "\"" + quoted + "\"" : quoted;
    }
}

package board.converter;

import static java.nio.charset.StandardCharsets.UTF_8;

import java.io.IOException;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;

public final class PostCsvHttpMessageConverter
        extends AbstractHttpMessageConverter<PostResponse> {
    public static final MediaType TEXT_CSV =
            new MediaType("text", "csv", UTF_8);

    public PostCsvHttpMessageConverter() {
        super(UTF_8, TEXT_CSV);
    }

    @Override
    public boolean canRead(Class<?> type, MediaType mediaType) {
        return false;
    }

    @Override
    protected boolean supports(Class<?> type) {
        return type == PostResponse.class;
    }

    @Override
    protected PostResponse readInternal(
            Class<? extends PostResponse> type,
            HttpInputMessage input) {
        throw new UnsupportedOperationException("CSV request is not supported");
    }

    @Override
    protected void writeInternal(
            PostResponse post,
            HttpOutputMessage output) throws IOException {
        var csv = "id,title,content\n"
                + post.id() + ","
                + Csv.field(post.title()) + ","
                + Csv.field(post.content()) + "\n";
        output.getBody().write(csv.getBytes(UTF_8));
    }
}

package board.converter;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverters;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration(proxyBeanMethods = false)
public class WebConverterConfig implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(
            HttpMessageConverters.ServerBuilder builder) {
        builder.addCustomConverter(new PostCsvHttpMessageConverter());
    }
}

package board.converter;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/converter/posts")
public final class NegotiatedPostController {
    private final PostQuery query;
    private final ConverterProbe probe;

    public NegotiatedPostController(PostQuery query, ConverterProbe probe) {
        this.query = query;
        this.probe = probe;
    }

    @GetMapping(
            path = "/{id}",
            produces = {"application/json", "text/csv"})
    public PostResponse get(@PathVariable long id) {
        probe.controllerEntered();
        return query.required(id);
    }

    @PostMapping(
            path = "/echo",
            consumes = "application/json",
            produces = "application/json")
    public PostResponse echoJson(@RequestBody PostResponse post) {
        probe.controllerEntered();
        return post;
    }

    @PostMapping(
            path = "/echo",
            consumes = "text/csv",
            produces = "application/json")
    public PostResponse echoCsv(@RequestBody PostResponse post) {
        probe.controllerEntered();
        return post;
    }

    @GetMapping(
            path = "/unwritable",
            produces = "application/x-board-post")
    public UnwritablePayload unwritable() {
        probe.controllerEntered();
        return new UnwritablePayload("writer 없음");
    }

    public record UnwritablePayload(String message) {
    }
}

package board.converter;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_XML;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import java.io.IOException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.ResourceHttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.JacksonJsonHttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.client.RestTestClient;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;

@SpringBootTest(classes = ConverterTestApplication.class)
@AutoConfigureMockMvc
class MessageConverterContractTest {
    private static final String POST_URI = "/api/converter/posts/42";
    private static final String ECHO_URI = "/api/converter/posts/echo";
    private static final MediaType UNWRITABLE =
            MediaType.parseMediaType("application/x-board-post");

    @Autowired
    private MockMvc mvc;

    @Autowired
    private ConverterProbe probe;

    @Autowired
    private RequestMappingHandlerAdapter adapter;

    @BeforeEach
    void resetProbe() {
        probe.reset();
    }

    @Test
    void Boot_기본_converter와_CSV_converter를_함께_유지한다() {
        var converters = adapter.getMessageConverters();

        assertThat(converters.getFirst())
                .isInstanceOf(PostCsvHttpMessageConverter.class);
        assertThat(converters.stream()
                .filter(PostCsvHttpMessageConverter.class::isInstance)
                .count())
                .isEqualTo(1);
        assertThat(converters)
                .anyMatch(JacksonJsonHttpMessageConverter.class::isInstance)
                .anyMatch(StringHttpMessageConverter.class::isInstance)
                .anyMatch(ResourceHttpMessageConverter.class::isInstance);
    }

    @Test
    void JSON_Accept는_Jackson3로_200_JSON을_쓴다() throws Exception {
        mvc.perform(get(POST_URI).accept(APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(APPLICATION_JSON))
                .andExpect(jsonPath("$.id").value(42))
                .andExpect(jsonPath("$.title").value("JSON, CSV"))
                .andExpect(jsonPath("$.content")
                        .value("같은 게시글을 CSV로 표현"));

        assertThat(probe.controllerCalls()).isEqualTo(1);
    }

    @Test
    void CSV_Accept는_custom_converter로_200_CSV를_쓴다() throws Exception {
        mvc.perform(get(POST_URI).accept(PostCsvHttpMessageConverter.TEXT_CSV))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(
                        PostCsvHttpMessageConverter.TEXT_CSV))
                .andExpect(content().string(
                        "id,title,content\n"
                                + "42,\"JSON, CSV\",같은 게시글을 CSV로 표현\n"));

        assertThat(probe.controllerCalls()).isEqualTo(1);
    }

    @Test
    void XML_Accept는_406이고_controller는_0회다() throws Exception {
        mvc.perform(get(POST_URI).accept(APPLICATION_XML))
                .andExpect(status().isNotAcceptable());

        assertThat(probe.controllerCalls()).isZero();
    }

    @Test
    void 읽기_미지원_CSV는_415이고_controller는_0회다() throws Exception {
        mvc.perform(post(ECHO_URI)
                        .contentType(PostCsvHttpMessageConverter.TEXT_CSV)
                        .accept(APPLICATION_JSON)
                        .content("id,title,content\n42,title,content\n"))
                .andExpect(status().isUnsupportedMediaType());

        assertThat(probe.controllerCalls()).isZero();
    }

    @Test
    void 선택된_JSON_reader의_문법_실패는_400이고_controller는_0회다()
            throws Exception {
        mvc.perform(post(ECHO_URI)
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .content("{\"id\":42,"))
                .andExpect(status().isBadRequest());

        assertThat(probe.controllerCalls()).isZero();
    }

    @Test
    void 고정_produces에_writer가_없으면_controller_후_500이다()
            throws Exception {
        var result = mvc.perform(get("/api/converter/posts/unwritable")
                        .accept(UNWRITABLE))
                .andExpect(status().isInternalServerError())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(HttpMessageNotWritableException.class);
        assertThat(probe.controllerCalls()).isEqualTo(1);
    }

    @Test
    void 넓은_선두_converter는_JSON을_가로챈다() {
        var client = RestTestClient
                .bindToController(new NegotiatedPostController(
                        new FixedPostQuery(), new ConverterProbe()))
                .configureServer(builder -> builder.setMessageConverters(
                        new GreedyHttpMessageConverter(),
                        new JacksonJsonHttpMessageConverter()))
                .build();

        client.get()
                .uri(POST_URI)
                .accept(APPLICATION_JSON)
                .exchange()
                .expectStatus().isOk()
                .expectHeader().contentTypeCompatibleWith(APPLICATION_JSON)
                .expectBody(String.class).isEqualTo("intercepted");

        assertThat(new PostCsvHttpMessageConverter()
                .canWrite(PostResponse.class, APPLICATION_JSON))
                .isFalse();
    }

    private static final class GreedyHttpMessageConverter
            extends AbstractHttpMessageConverter<Object> {
        private GreedyHttpMessageConverter() {
            super(MediaType.ALL);
        }

        @Override
        protected boolean supports(Class<?> type) {
            return true;
        }

        @Override
        protected Object readInternal(
                Class<? extends Object> type,
                HttpInputMessage input) {
            throw new UnsupportedOperationException("read is not used");
        }

        @Override
        protected void writeInternal(
                Object value,
                HttpOutputMessage output) throws IOException {
            output.getBody().write("intercepted".getBytes(UTF_8));
        }
    }
}