뷰·리다이렉트·응답 본문

rootProject.name = 'mvc-return-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-thymeleaf'
    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;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BoardApplication {
    public static void main(String[] args) {
        SpringApplication.run(BoardApplication.class, args);
    }
}

package board.post;

import java.util.Objects;

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

package board.post;

@FunctionalInterface
public interface PostQuery {
    Post findById(long id);
}

package board.post;

@FunctionalInterface
public interface PostService {
    Post register(String title, String content);
}

package board.web;

import board.post.Post;

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

package board.web;

import board.post.Post;

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

package board.web;

import board.post.PostQuery;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
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.servlet.view.RedirectView;

@Controller
@RequestMapping("/posts")
public final class PostViewController {
    private final PostQuery query;

    public PostViewController(PostQuery query) {
        this.query = query;
    }

    @GetMapping("/{id}")
    public String detail(@PathVariable long id, Model model) {
        model.addAttribute("post", PostPageModel.from(query.findById(id)));
        return "post-detail";
    }

    @GetMapping("/{id}/redirect-default")
    public String redirectWithFrameworkDefault(@PathVariable long id) {
        return "redirect:/posts/" + id;
    }

    @GetMapping("/{id}/redirect-explicit")
    public RedirectView redirectWithExplicitContract(@PathVariable long id, Model model) {
        model.addAttribute("campaign", "must-not-leak");
        var redirect = new RedirectView("/posts/" + id, true);
        redirect.setStatusCode(HttpStatus.SEE_OTHER);
        redirect.setExposeModelAttributes(false);
        return redirect;
    }
}

<!doctype html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
  <head>
    <meta charset="UTF-8" />
    <title th:text="${post.title} + ' | Board'">Post | Board</title>
  </head>
  <body>
    <main>
      <article th:attr="data-post-id=${post.id}">
        <h1 th:text="${post.title}">Post title</h1>
        <p th:text="${post.content}">Post content</p>
      </article>
    </main>
  </body>
</html>

package board.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/status")
public final class PlainStatusController {
    @GetMapping
    @ResponseBody
    public String ready() {
        return "ready";
    }

    @GetMapping("/misplaced-view-name")
    @ResponseBody
    public String misplacedViewName() {
        return "post-detail";
    }
}

package board.web;

import board.post.PostQuery;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
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;

@RestController
@RequestMapping("/api/posts")
public final class PostQueryController {
    private final PostQuery query;

    public PostQueryController(PostQuery query) {
        this.query = query;
    }

    @GetMapping("/{id}")
    public PostResponse find(@PathVariable long id) {
        return PostResponse.from(query.findById(id));
    }

    @GetMapping("/{id}/entity")
    public HttpEntity<PostResponse> findAsEntity(@PathVariable long id) {
        var headers = new HttpHeaders();
        headers.set("X-Return-Contract", "http-entity");
        return new HttpEntity<>(PostResponse.from(query.findById(id)), headers);
    }
}

package board.web;

import board.post.PostService;
import java.net.URI;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public final class PostFormCommandController {
    private final PostService service;

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

    @PostMapping(path = "/posts", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
    public ResponseEntity<Void> register(
            @RequestParam String title, @RequestParam String content) {
        var post = service.register(title, content);
        return ResponseEntity.status(HttpStatus.SEE_OTHER)
                .location(URI.create("/posts/" + post.id()))
                .build();
    }
}

package board.web;

import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
import static org.springframework.http.MediaType.APPLICATION_FORM_URLENCODED;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.TEXT_HTML;
import static org.springframework.http.MediaType.TEXT_PLAIN;
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.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.model;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;

import board.post.Post;
import board.post.PostQuery;
import board.post.PostService;
import java.util.LinkedHashMap;
import java.util.Map;
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.test.context.TestConfiguration;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpHeaders;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest
@AutoConfigureMockMvc
@Import(ControllerReturnValueTest.TestBeans.class)
class ControllerReturnValueTest {
    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private RecordingPostStore store;

    @BeforeEach
    void resetStore() {
        store.reset();
    }

    @Test
    void controller_String은_정확한_논리_뷰와_모델을_선택한다() throws Exception {
        mockMvc.perform(get("/posts/42"))
                .andExpect(status().isOk())
                .andExpect(view().name("post-detail"))
                .andExpect(model().attribute(
                        "post",
                        new PostPageModel(
                                42L,
                                "반환값 확인",
                                "Thymeleaf가 실제 HTML을 렌더링합니다.")));
    }

    @Test
    void 같은_GET은_실제_Thymeleaf_HTML을_렌더링한다() throws Exception {
        mockMvc.perform(get("/posts/42"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(TEXT_HTML))
                .andExpect(content().string(containsString("반환값 확인 | Board")))
                .andExpect(content().string(containsString("data-post-id=\"42\"")))
                .andExpect(content().string(
                        containsString("Thymeleaf가 실제 HTML을 렌더링합니다.")));
    }

    @Test
    void ResponseBody_String은_정확한_plain_text_본문이다() throws Exception {
        mockMvc.perform(get("/status"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(TEXT_PLAIN))
                .andExpect(content().string("ready"));
    }

    @Test
    void 잘못_붙인_ResponseBody는_뷰_대신_리터럴을_쓴다() throws Exception {
        mockMvc.perform(get("/status/misplaced-view-name"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(TEXT_PLAIN))
                .andExpect(content().string("post-detail"))
                .andExpect(content().string(not(containsString("<html"))));
    }

    @Test
    void RestController_DTO는_JSON_필드를_쓴다() throws Exception {
        mockMvc.perform(get("/api/posts/42"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(APPLICATION_JSON))
                .andExpect(jsonPath("$.id").value(42))
                .andExpect(jsonPath("$.title").value("반환값 확인"))
                .andExpect(jsonPath("$.content")
                        .value("Thymeleaf가 실제 HTML을 렌더링합니다."));
    }

    @Test
    void HttpEntity_DTO는_기본_200과_헤더와_JSON을_쓴다() throws Exception {
        mockMvc.perform(get("/api/posts/42/entity"))
                .andExpect(status().isOk())
                .andExpect(header().string("X-Return-Contract", "http-entity"))
                .andExpect(content().contentTypeCompatibleWith(APPLICATION_JSON))
                .andExpect(jsonPath("$.id").value(42))
                .andExpect(jsonPath("$.title").value("반환값 확인"));
    }

    @Test
    void ResponseEntity_Void는_정확한_303_Location과_빈_본문이다() throws Exception {
        mockMvc.perform(post("/posts")
                        .contentType(APPLICATION_FORM_URLENCODED)
                        .param("title", "PRG")
                        .param("content", "명시적인 303으로 이동합니다."))
                .andExpect(status().is(303))
                .andExpect(header().string(HttpHeaders.LOCATION, "/posts/43"))
                .andExpect(content().string(""));

        assertThat(store.registrations()).isEqualTo(1);
    }

    @Test
    void 명시적_303_등록은_서비스를_정확히_한_번_호출한다() throws Exception {
        mockMvc.perform(post("/posts")
                        .contentType(APPLICATION_FORM_URLENCODED)
                        .param("title", "한 번")
                        .param("content", "등록 호출을 셉니다."))
                .andExpect(status().is(303));

        assertThat(store.registrations()).isEqualTo(1);
        assertThat(store.findById(43L))
                .isEqualTo(new Post(43L, "한 번", "등록 호출을 셉니다."));
    }

    @Test
    void Location을_따른_GET은_저장글을_렌더링하고_등록을_늘리지_않는다() throws Exception {
        var registration = mockMvc.perform(post("/posts")
                        .contentType(APPLICATION_FORM_URLENCODED)
                        .param("title", "후속 GET")
                        .param("content", "등록 뒤 조회만 수행합니다."))
                .andExpect(status().is(303))
                .andExpect(header().string(HttpHeaders.LOCATION, "/posts/43"))
                .andReturn();

        var location = registration.getResponse().getHeader(HttpHeaders.LOCATION);
        assertThat(store.registrations()).isEqualTo(1);

        mockMvc.perform(get(location))
                .andExpect(status().isOk())
                .andExpect(view().name("post-detail"))
                .andExpect(content().contentTypeCompatibleWith(TEXT_HTML))
                .andExpect(content().string(containsString("후속 GET")))
                .andExpect(content().string(containsString("등록 뒤 조회만 수행합니다.")));

        assertThat(store.registrations()).isEqualTo(1);
    }

    @Test
    void redirect_논리_뷰는_프레임워크_기본_302를_사용한다() throws Exception {
        mockMvc.perform(get("/posts/42/redirect-default"))
                .andExpect(status().is(302))
                .andExpect(view().name("redirect:/posts/42"))
                .andExpect(header().string(HttpHeaders.LOCATION, "/posts/42"))
                .andExpect(content().string(""));
    }

    @Test
    void RedirectView는_정확한_303이고_모델을_쿼리에_노출하지_않는다() throws Exception {
        var redirect = mockMvc.perform(get("/posts/42/redirect-explicit"))
                .andExpect(status().is(303))
                .andExpect(header().string(HttpHeaders.LOCATION, "/posts/42"))
                .andExpect(content().string(""))
                .andReturn();

        assertThat(redirect.getResponse().getHeader(HttpHeaders.LOCATION))
                .isEqualTo("/posts/42")
                .doesNotContain("campaign", "?");
    }

    @TestConfiguration(proxyBeanMethods = false)
    static class TestBeans {
        @Bean
        RecordingPostStore postStore() {
            return new RecordingPostStore();
        }
    }

    static final class RecordingPostStore implements PostQuery, PostService {
        private final Map<Long, Post> posts = new LinkedHashMap<>();
        private long nextId;
        private int registrations;

        RecordingPostStore() {
            reset();
        }

        @Override
        public Post findById(long id) {
            var post = posts.get(id);
            if (post == null) {
                throw new IllegalArgumentException("post not found: " + id);
            }
            return post;
        }

        @Override
        public Post register(String title, String content) {
            var post = new Post(nextId++, title, content);
            posts.put(post.id(), post);
            registrations++;
            return post;
        }

        int registrations() {
            return registrations;
        }

        void reset() {
            posts.clear();
            posts.put(
                    42L,
                    new Post(
                            42L,
                            "반환값 확인",
                            "Thymeleaf가 실제 HTML을 렌더링합니다."));
            nextId = 43L;
            registrations = 0;
        }
    }
}