RequestMapping 조건

rootProject.name = 'request-mapping-conditions'

plugins {
    id 'java'
}

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

repositories {
    mavenCentral()
}

dependencies {
    implementation platform(
            'org.springframework.boot:spring-boot-dependencies:4.1.1')
    implementation 'org.springframework.boot:spring-boot-starter-webmvc'
    testImplementation platform(
            'org.springframework.boot:spring-boot-dependencies:4.1.1')
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    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.post;

public record Post(
        long id,
        String title,
        String content) {}

package board.post;

public record ReplacePostCommand(
        String title,
        String content) {}

package board.post;

import java.util.Optional;

public interface PostService {
    Optional<Post> find(long postId);

    Post replace(
            long postId,
            ReplacePostCommand command);

    Post search();
}

package board.web;

import board.post.ReplacePostCommand;

public record ReplacePostRequest(
        String title,
        String content) {
    ReplacePostCommand toCommand() {
        return new ReplacePostCommand(
                title,
                content);
    }
}

package board.web;

import board.post.Post;

public record PostResponse(
        long id,
        String title,
        String content) {
    static PostResponse from(Post post) {
        return new PostResponse(
                post.id(),
                post.title(),
                post.content());
    }
}

package board.web;

import static org.springframework.http.MediaType
        .APPLICATION_JSON_VALUE;

import board.post.PostService;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@RestController
@RequestMapping(
        path = "/api/posts",
        produces = APPLICATION_JSON_VALUE)
public final class PostCommandController {
    private final PostService service;

    public PostCommandController(PostService service) {
        this.service = service;
    }

    @GetMapping("/search")
    PostResponse search() {
        return PostResponse.from(service.search());
    }

    @GetMapping("/{postId}")
    PostResponse get(
            @PathVariable("postId") long postId) {
        return service.find(postId)
                .map(PostResponse::from)
                .orElseThrow(() ->
                        new ResponseStatusException(
                                HttpStatus.NOT_FOUND,
                                "post not found"));
    }

    @PutMapping(
            path = "/{postId}",
            consumes = APPLICATION_JSON_VALUE)
    PostResponse replace(
            @PathVariable("postId") long postId,
            @RequestBody ReplacePostRequest request) {
        return PostResponse.from(
                service.replace(
                        postId,
                        request.toCommand()));
    }
}

package board.web;

import static java.util.stream.Collectors.toSet;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.springframework.http.MediaType.APPLICATION_JSON;
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.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.handler;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;

import board.post.Post;
import board.post.PostService;
import board.post.ReplacePostCommand;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.servlet.NoHandlerFoundException;

class RequestMappingConditionsTest {
    private static final Post POST =
            new Post(42L, "기존 제목", "기존 본문");

    @Test
    void 모든_조건이_맞은_GET과_PUT은_handler를_호출한다()
            throws Exception {
        var fixture = fixture(POST);

        fixture.mvc().perform(get("/api/posts/42")
                        .accept(APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content()
                        .contentTypeCompatibleWith(
                                APPLICATION_JSON))
                .andExpect(jsonPath("$.id").value(42))
                .andExpect(jsonPath("$.title")
                        .value("기존 제목"));

        fixture.mvc().perform(put("/api/posts/42")
                        .contentType(APPLICATION_JSON)
                        .accept(APPLICATION_JSON)
                        .content("""
                                {
                                  "title": "교체 제목",
                                  "content": "교체 본문"
                                }
                                """))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(42))
                .andExpect(jsonPath("$.title")
                        .value("교체 제목"));

        assertThat(fixture.service().operations())
                .containsExactly("find:42", "replace:42");
    }

    @Test
    void 경로_후보가_없으면_mapping_404다()
            throws Exception {
        var fixture = fixture(POST);

        var result = fixture.mvc()
                .perform(get("/api/other/42"))
                .andExpect(status().isNotFound())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(
                        NoHandlerFoundException.class);
        assertThat(fixture.service().operations()).isEmpty();
    }

    @Test
    void 경로만_맞고_method가_다르면_405와_Allow를_반환한다()
            throws Exception {
        var fixture = fixture(POST);

        var result = fixture.mvc()
                .perform(post("/api/posts/42"))
                .andExpect(status().isMethodNotAllowed())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(
                        HttpRequestMethodNotSupportedException.class);
        var allow = result.getResponse()
                .getHeader(HttpHeaders.ALLOW);
        assertThat(allow).isNotNull();
        var methods = Arrays.stream(allow.split(","))
                .map(String::trim)
                .collect(toSet());
        assertThat(methods)
                .containsExactlyInAnyOrder(
                        "GET", "PUT");
        assertThat(fixture.service().operations()).isEmpty();
    }

    @Test
    void PUT의_ContentType이_다르면_415다()
            throws Exception {
        var fixture = fixture(POST);

        var result = fixture.mvc()
                .perform(put("/api/posts/42")
                        .contentType(MediaType.TEXT_PLAIN)
                        .content("plain text"))
                .andExpect(status()
                        .isUnsupportedMediaType())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(
                        HttpMediaTypeNotSupportedException.class);
        assertThat(fixture.service().operations()).isEmpty();
    }

    @Test
    void GET의_Accept가_다르면_406이다()
            throws Exception {
        var fixture = fixture(POST);

        var result = fixture.mvc()
                .perform(get("/api/posts/42")
                        .accept(MediaType.APPLICATION_XML))
                .andExpect(status().isNotAcceptable())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(
                        HttpMediaTypeNotAcceptableException.class);
        assertThat(fixture.service().operations()).isEmpty();
    }

    @Test
    void literal_search가_경로_변수보다_구체적이다()
            throws Exception {
        var fixture = fixture(POST);

        fixture.mvc().perform(get("/api/posts/search")
                        .accept(APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(handler().methodName("search"))
                .andExpect(jsonPath("$.id").value(7));

        assertThat(fixture.service().operations())
                .containsExactly("search");
    }

    @Test
    void 숫자가_아닌_경로_변수는_handler_인자_변환_400이다()
            throws Exception {
        var fixture = fixture(POST);

        var result = fixture.mvc()
                .perform(get("/api/posts/not-a-number"))
                .andExpect(status().isBadRequest())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(
                        MethodArgumentTypeMismatchException.class);
        assertThat(fixture.service().operations()).isEmpty();
    }

    @Test
    void 숫자_ID의_리소스_없음은_handler_진입_뒤_404다()
            throws Exception {
        var fixture = fixture(POST);

        var result = fixture.mvc()
                .perform(get("/api/posts/999999"))
                .andExpect(status().isNotFound())
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(ResponseStatusException.class);
        assertThat(fixture.service().operations())
                .containsExactly("find:999999");
    }

    @Test
    void 완전히_같은_mapping은_등록할_수_없다() {
        assertThatThrownBy(() ->
                standaloneSetup(
                        new DuplicateMappingController())
                        .build())
                .isInstanceOf(IllegalStateException.class)
                .hasMessageContaining("Ambiguous mapping");
    }

    private static Fixture fixture(Post... posts) {
        var service = new RecordingPostService(posts);
        var mvc = standaloneSetup(
                        new PostCommandController(service))
                .build();
        return new Fixture(mvc, service);
    }

    private record Fixture(
            MockMvc mvc,
            RecordingPostService service) {}

    private static final class RecordingPostService
            implements PostService {
        private final LinkedHashMap<Long, Post> posts =
                new LinkedHashMap<>();
        private final ArrayList<String> operations =
                new ArrayList<>();

        RecordingPostService(Post... posts) {
            for (var post : posts) {
                this.posts.put(post.id(), post);
            }
        }

        @Override
        public Optional<Post> find(long postId) {
            operations.add("find:" + postId);
            return Optional.ofNullable(posts.get(postId));
        }

        @Override
        public Post replace(
                long postId,
                ReplacePostCommand command) {
            operations.add("replace:" + postId);
            var post = new Post(
                    postId,
                    command.title(),
                    command.content());
            posts.put(postId, post);
            return post;
        }

        @Override
        public Post search() {
            operations.add("search");
            return new Post(
                    7L,
                    "검색 결과",
                    "literal mapping");
        }

        List<String> operations() {
            return List.copyOf(operations);
        }
    }

    @RestController
    @RequestMapping("/duplicate")
    private static final class DuplicateMappingController {
        @GetMapping
        void first() {}

        @GetMapping
        void second() {}
    }
}