게시판 웹 통합

package board.application.postcreation;

import java.time.LocalDate;
import java.util.Objects;

public interface CreatePostUseCase {
    PostResponse handle(CreatePostCommand command);

    record CreatePostCommand(
            long memberId,
            String title,
            String content,
            LocalDate publishedOn,
            String clientRequestId
    ) {
        public CreatePostCommand {
            if (memberId <= 0) {
                throw new IllegalArgumentException("memberId must be positive");
            }
            Objects.requireNonNull(publishedOn, "publishedOn");
            if (title == null || title.isBlank() || title.length() > 80) {
                throw new IllegalArgumentException("invalid title");
            }
            if (content == null || content.isBlank()
                    || content.length() > 720) {
                throw new IllegalArgumentException("invalid content");
            }
            if (clientRequestId == null
                    || !clientRequestId.matches("[A-Za-z0-9_-]{8,64}")) {
                throw new IllegalArgumentException("invalid clientRequestId");
            }
        }
    }

    record PostResponse(long id, long version, String title, String content) {
        public PostResponse {
            if (id <= 0 || version < 0) {
                throw new IllegalArgumentException("invalid response identity");
            }
            Objects.requireNonNull(title, "title");
            Objects.requireNonNull(content, "content");
        }
    }
}

package board.web.postcreation;

import static board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import static board.application.postcreation.CreatePostUseCase.PostResponse;

import java.net.URI;
import java.time.LocalDate;

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.PastOrPresent;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;

import board.application.postcreation.CreatePostUseCase;
import board.web.auth.CurrentMember;
import board.web.auth.LoginRequired;
import board.web.auth.SessionMemberReader.AuthenticatedMember;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@LoginRequired
public final class IntegratedPostController {
    private final CreatePostUseCase register;

    public IntegratedPostController(CreatePostUseCase register) {
        this.register = register;
    }

    @PostMapping("/api/posts")
    ResponseEntity<PostResponse> create(
            @CurrentMember AuthenticatedMember member,
            @Valid @RequestBody CreatePostRequest request
    ) {
        var command = new CreatePostCommand(
                member.id(),
                request.title().strip(),
                request.content(),
                request.publishedOn(),
                request.clientRequestId());
        PostResponse response = register.handle(command);
        return ResponseEntity
                .created(URI.create("/api/posts/" + response.id()))
                .eTag("\"" + response.version() + "\"")
                .body(response);
    }

    public record CreatePostRequest(
            @NotBlank @Size(max = 80) String title,
            @NotBlank @Size(max = 720) String content,
            @NotNull @PastOrPresent LocalDate publishedOn,
            @NotBlank
            @Pattern(regexp = "[A-Za-z0-9_-]{8,64}")
            String clientRequestId
    ) {
    }
}

package board.application.postcreation;

import static board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import static board.application.postcreation.CreatePostUseCase.PostResponse;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Objects;
import java.util.Optional;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class CreatePostService
        implements CreatePostUseCase {
    private final MemberRepository members;
    private final PostRepository posts;
    private final Clock clock;

    public CreatePostService(
            MemberRepository members,
            PostRepository posts,
            Clock clock
    ) {
        this.members = members;
        this.posts = posts;
        this.clock = clock;
    }

    @Override
    @Transactional
    public PostResponse handle(CreatePostCommand command) {
        var previous = posts.findByIdempotencyKey(
                command.memberId(), command.clientRequestId());
        if (previous.isPresent()) {
            previous.get().requireSamePayload(command);
            return response(previous.get());
        }

        var member = members.required(command.memberId());
        member.requireActive();
        int used = posts.totalCharacters(
                member.id(), command.publishedOn());
        member.requireDailyLimit(used, command.content().length());

        var post = Post.register(
                member.id(),
                command.title(),
                command.content(),
                command.publishedOn(),
                command.clientRequestId(),
                clock.instant());
        Post saved = posts.save(post);
        return response(saved);
    }

    private PostResponse response(Post post) {
        return new PostResponse(
                post.id(), post.version(), post.title(), post.content());
    }
}

interface MemberRepository {
    Member required(long memberId);
}

interface PostRepository {
    Optional<Post> findByIdempotencyKey(
            long memberId, String clientRequestId);

    int totalCharacters(long memberId, LocalDate publishedOn);

    Post save(Post post);
}

record Member(long id, boolean active, int dailyCharacterLimit) {
    Member {
        if (id <= 0 || dailyCharacterLimit < 1) {
            throw new IllegalArgumentException("invalid member state");
        }
    }

    void requireActive() {
        if (!active) {
            throw new MemberInactiveException();
        }
    }

    void requireDailyLimit(int usedCharacters, int attemptedCharacters) {
        if ((long) usedCharacters + attemptedCharacters
                > dailyCharacterLimit) {
            throw new DailyLimitExceededException(
                    dailyCharacterLimit,
                    usedCharacters,
                    attemptedCharacters);
        }
    }
}

record Post(
        long id,
        long version,
        long memberId,
        String title,
        String content,
        LocalDate publishedOn,
        String clientRequestId,
        Instant createdAt
) {
    static Post register(
            long memberId,
            String title,
            String content,
            LocalDate publishedOn,
            String clientRequestId,
            Instant createdAt
    ) {
        return new Post(
                0L, 0L, memberId, title, content,
                publishedOn, clientRequestId, createdAt);
    }

    void requireSamePayload(CreatePostCommand command) {
        if (memberId != command.memberId()
                || !title.equals(command.title())
                || !content.equals(command.content())
                || !publishedOn.equals(command.publishedOn())
                || !clientRequestId.equals(command.clientRequestId())) {
            throw new IdempotencyKeyConflictException(clientRequestId);
        }
    }
}

final class MemberInactiveException extends RuntimeException {
}

final class IdempotencyKeyConflictException extends RuntimeException {
    IdempotencyKeyConflictException(String clientRequestId) {
        super("idempotency key reused with another payload: "
                + Objects.requireNonNull(clientRequestId));
    }
}

package board.application.postcreation;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneOffset;
import java.util.Optional;

import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import board.application.postcreation.CreatePostUseCase.PostResponse;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class CreatePostServiceTest {
    private static final Instant NOW = Instant.parse(
            "2026-07-14T03:00:00Z");

    @Mock
    MemberRepository members;

    @Mock
    PostRepository posts;

    Clock clock = Clock.fixed(NOW, ZoneOffset.UTC);

    @Test
    void 같은_멱등성_key와_payload는_저장하지_않고_기존_결과를_재생한다() {
        var command = command("Spring MVC 본문", "request-0001");
        var existing = new Post(
                91L, 3L, 41L, "Spring", "Spring MVC 본문",
                LocalDate.of(2026, 7, 14), "request-0001", NOW);
        when(posts.findByIdempotencyKey(41L, "request-0001"))
                .thenReturn(Optional.of(existing));
        var service = new CreatePostService(members, posts, clock);

        assertThat(service.handle(command)).isEqualTo(
                new PostResponse(91L, 3L, "Spring", "Spring MVC 본문"));
        verify(posts, never()).save(any());
        verifyNoInteractions(members);
    }

    @Test
    void 실제_사용량과_시도량이_한도를_넘으면_save하지_않는다() {
        var command = command(
                "1234567890123456789012345678901234567890",
                "request-0002");
        when(posts.findByIdempotencyKey(41L, "request-0002"))
                .thenReturn(Optional.empty());
        when(members.required(41L)).thenReturn(new Member(41L, true, 720));
        when(posts.totalCharacters(41L, LocalDate.of(2026, 7, 14)))
                .thenReturn(700);
        var service = new CreatePostService(members, posts, clock);

        Throwable thrown = catchThrowable(() -> service.handle(command));

        assertThat(thrown).isInstanceOf(DailyLimitExceededException.class);
        var exceeded = (DailyLimitExceededException) thrown;
        assertThat(exceeded.limitCharacters()).isEqualTo(720);
        assertThat(exceeded.usedCharacters()).isEqualTo(700);
        assertThat(exceeded.attemptedCharacters()).isEqualTo(40);
        verify(posts, never()).save(any());
    }

    private CreatePostCommand command(String content, String requestId) {
        return new CreatePostCommand(
                41L,
                "Spring",
                content,
                LocalDate.of(2026, 7, 14),
                requestId);
    }
}

package board.application.postcreation;

public final class DailyLimitExceededException extends RuntimeException {
    private final int limitCharacters;
    private final int usedCharacters;
    private final int attemptedCharacters;

    public DailyLimitExceededException(
            int limitCharacters,
            int usedCharacters,
            int attemptedCharacters
    ) {
        super("daily character limit exceeded");
        if (limitCharacters < 1
                || usedCharacters < 0
                || attemptedCharacters < 1
                || (long) usedCharacters + attemptedCharacters
                        <= limitCharacters) {
            throw new IllegalArgumentException(
                    "values must describe an exceeded limit");
        }
        this.limitCharacters = limitCharacters;
        this.usedCharacters = usedCharacters;
        this.attemptedCharacters = attemptedCharacters;
    }

    public int limitCharacters() {
        return limitCharacters;
    }

    public int usedCharacters() {
        return usedCharacters;
    }

    public int attemptedCharacters() {
        return attemptedCharacters;
    }
}

package board.web.postcreation;

import java.net.URI;

import jakarta.servlet.http.HttpServletRequest;

import board.application.postcreation.DailyLimitExceededException;
import board.web.RequestTraceFilter;

import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(assignableTypes = IntegratedPostController.class)
@Order(Ordered.HIGHEST_PRECEDENCE)
public final class DailyLimitAdvice {
    @ExceptionHandler(DailyLimitExceededException.class)
    ProblemDetail dailyLimit(
            DailyLimitExceededException exception,
            HttpServletRequest request
    ) {
        Object trace = request.getAttribute(
                RequestTraceFilter.REQUEST_ID_ATTRIBUTE);
        if (!(trace instanceof String requestId) || requestId.isBlank()) {
            throw new IllegalStateException(
                    "RequestTraceFilter must run before MVC");
        }
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(
                HttpStatus.CONFLICT,
                "선택한 게시일에 등록할 수 있는 본문 길이를 초과했습니다.");
        problem.setType(URI.create(
                "https://board.example/problems/post-daily-limit"));
        problem.setTitle("게시글 게시일별 본문 한도 초과");
        problem.setProperty("code", "daily-limit-exceeded");
        problem.setProperty("limitCharacters", exception.limitCharacters());
        problem.setProperty("usedCharacters", exception.usedCharacters());
        problem.setProperty(
                "attemptedCharacters", exception.attemptedCharacters());
        problem.setProperty("requestId", requestId);
        return problem;
    }
}

package board.web.postcreation;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
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.status;

import java.time.LocalDate;

import board.application.postcreation.CreatePostUseCase;
import board.application.postcreation.CreatePostUseCase.CreatePostCommand;
import board.application.postcreation.CreatePostUseCase.PostResponse;
import board.application.postcreation.DailyLimitExceededException;
import board.web.RequestTraceFilter;
import board.web.auth.AuthWebMvcConfiguration;
import board.web.auth.SessionMemberReader;
import board.web.auth.SessionMemberReader.AuthenticatedMember;

import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.context.annotation.Import;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.web.bind.MethodArgumentNotValidException;

@WebMvcTest(IntegratedPostController.class)
@Import({
        AuthWebMvcConfiguration.class,
        RequestTraceFilter.class,
        DailyLimitAdvice.class
})
class PostCreationFlowTest {
    @Autowired
    MockMvc mvc;

    @MockitoBean
    CreatePostUseCase register;

    @Test
    void 익명_API_요청은_401_problem으로_끝나고_use_case를_호출하지_않는다()
            throws Exception {
        mvc.perform(post("/api/posts")
                        .header(RequestTraceFilter.REQUEST_ID_HEADER,
                                "anonymous-0001"))
                .andExpect(status().isUnauthorized())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(header().string(
                        RequestTraceFilter.REQUEST_ID_HEADER,
                        "anonymous-0001"))
                .andExpect(jsonPath("$.type").value(
                        "https://board.example/problems/authentication-required"))
                .andExpect(jsonPath("$.title").value("인증 필요"))
                .andExpect(jsonPath("$.status").value(401))
                .andExpect(jsonPath("$.detail").value("로그인이 필요합니다."))
                .andExpect(jsonPath("$.code")
                        .value("authentication-required"))
                .andExpect(jsonPath("$.requestId").doesNotExist());

        verifyNoInteractions(register);
    }

    @Test
    void 잘못된_body는_인증됐어도_use_case를_호출하지_않는다()
            throws Exception {
        var result = mvc.perform(post("/api/posts")
                        .header(RequestTraceFilter.REQUEST_ID_HEADER,
                                "validation-0001")
                        .session(authenticated(41L))
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {"title":"","content":"",
                                 "publishedOn":"2026-07-14",
                                 "clientRequestId":"request-0001"}
                                """))
                .andExpect(status().isBadRequest())
                .andExpect(header().string(
                        RequestTraceFilter.REQUEST_ID_HEADER,
                        "validation-0001"))
                .andReturn();

        assertThat(result.getResolvedException())
                .isInstanceOf(MethodArgumentNotValidException.class);
        verifyNoInteractions(register);
    }

    @Test
    void 정상_요청은_201_Location_ETag와_같은_request_id를_반환한다()
            throws Exception {
        when(register.handle(any())).thenReturn(
                new PostResponse(91L, 3L, "Spring", "Spring MVC 본문"));

        mvc.perform(post("/api/posts")
                        .header(RequestTraceFilter.REQUEST_ID_HEADER,
                                "creation-0002")
                        .session(authenticated(41L))
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {"title":" Spring ",
                                 "content":"Spring MVC 본문",
                                 "publishedOn":"2026-07-14",
                                 "clientRequestId":"request-0002"}
                                """))
                .andExpect(status().isCreated())
                .andExpect(header().string("Location", "/api/posts/91"))
                .andExpect(header().string("ETag", "\"3\""))
                .andExpect(header().string(
                        RequestTraceFilter.REQUEST_ID_HEADER,
                        "creation-0002"));

        var command = ArgumentCaptor.forClass(CreatePostCommand.class);
        verify(register).handle(command.capture());
        assertThat(command.getValue()).isEqualTo(new CreatePostCommand(
                41L,
                "Spring",
                "Spring MVC 본문",
                LocalDate.of(2026, 7, 14),
                "request-0002"));
    }

    @Test
    void 게시일별_한도는_409_ProblemDetail과_request_id로_고정된다()
            throws Exception {
        when(register.handle(any())).thenThrow(
                new DailyLimitExceededException(720, 700, 40));

        mvc.perform(post("/api/posts")
                        .header(RequestTraceFilter.REQUEST_ID_HEADER,
                                "creation-0003")
                        .session(authenticated(41L))
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {"title":"Spring",
                                 "content":"1234567890123456789012345678901234567890",
                                 "publishedOn":"2026-07-14",
                                 "clientRequestId":"request-0003"}
                                """))
                .andExpect(status().isConflict())
                .andExpect(content().contentTypeCompatibleWith(
                        MediaType.APPLICATION_PROBLEM_JSON))
                .andExpect(header().string(
                        RequestTraceFilter.REQUEST_ID_HEADER,
                        "creation-0003"))
                .andExpect(jsonPath("$.type").value(
                        "https://board.example/problems/post-daily-limit"))
                .andExpect(jsonPath("$.title")
                        .value("게시글 게시일별 본문 한도 초과"))
                .andExpect(jsonPath("$.status").value(409))
                .andExpect(jsonPath("$.detail")
                        .value("선택한 게시일에 등록할 수 있는 본문 길이를 초과했습니다."))
                .andExpect(jsonPath("$.code")
                        .value("daily-limit-exceeded"))
                .andExpect(jsonPath("$.limitCharacters").value(720))
                .andExpect(jsonPath("$.usedCharacters").value(700))
                .andExpect(jsonPath("$.attemptedCharacters").value(40))
                .andExpect(jsonPath("$.requestId")
                        .value("creation-0003"));

        verify(register).handle(any());
    }

    private MockHttpSession authenticated(long memberId) {
        var session = new MockHttpSession();
        session.setAttribute(
                SessionMemberReader.AUTHENTICATED_MEMBER_ATTRIBUTE,
                new AuthenticatedMember(memberId));
        return session;
    }
}

anonymous API -> 401 code=authentication-required, use-case calls 0
anonymous X-Request-Id = anonymous-0001
invalid body -> 400 MethodArgumentNotValidException, use-case calls 0
valid body -> 201
Location = /api/posts/91
ETag = "3"
X-Request-Id = creation-0002
captured command memberId = 41, title = Spring
published-date limit -> 409 code=daily-limit-exceeded
published-date limit requestId = creation-0003

package board;

import java.time.Clock;
import java.util.Optional;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import board.web.auth.LoginController.CredentialVerifier;
import board.web.auth.MemberPostQuery;
import board.web.problem.PostNotFoundException;
import board.web.problem.ProblemPostQuery;

@Configuration(proxyBeanMethods = false)
public class BoardPortConfiguration {
    @Bean
    Clock clock() {
        return Clock.systemUTC();
    }

    @Bean
    CredentialVerifier credentialVerifier() {
        return (email, password) -> Optional.empty();
    }

    @Bean
    MemberPostQuery memberPostQuery() {
        return memberId -> {
            throw new IllegalStateException(
                    "member post store is not connected");
        };
    }

    @Bean
    ProblemPostQuery problemPostQuery() {
        return new ProblemPostQuery() {
            @Override
            public PostSummary required(long postId) {
                throw new PostNotFoundException(postId);
            }

            @Override
            public void createDuplicate(long postId) {
                throw new PostNotFoundException(postId);
            }
        };
    }
}

package board.web.attachment;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class AttachmentPortConfiguration {
    @Bean
    AttachmentService attachmentService() {
        return (memberId, metadata, file) -> {
            throw new IllegalStateException(
                    "attachment storage is not connected");
        };
    }
}

package board.application.postcreation;

import java.time.LocalDate;
import java.util.Optional;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class PostCreationPortConfiguration {
    @Bean
    MemberRepository memberRepository() {
        return memberId -> {
            throw notConnected();
        };
    }

    @Bean
    PostRepository postRepository() {
        return new PostRepository() {
            @Override
            public Optional<Post> findByIdempotencyKey(
                    long memberId, String clientRequestId) {
                throw notConnected();
            }

            @Override
            public int totalCharacters(long memberId, LocalDate publishedOn) {
                throw notConnected();
            }

            @Override
            public Post save(Post post) {
                throw notConnected();
            }
        };
    }

    private static IllegalStateException notConnected() {
        return new IllegalStateException("post store is not connected");
    }
}

package board;

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

import board.application.postcreation.CreatePostService;
import board.application.postcreation.CreatePostUseCase;
import board.web.attachment.AttachmentController;
import board.web.auth.CurrentMemberController;
import board.web.auth.LoginController;
import board.web.postcreation.IntegratedPostController;
import board.web.problem.ProblemPostController;
import board.web.problem.ProblemPostPageController;

@SpringBootTest
class BoardApplicationStartupTest {
    @Autowired
    ApplicationContext context;

    @Test
    void 전체_구성은_포트가_필요한_컨트롤러와_서비스를_모두_만든다() {
        assertThat(context.getBeanNamesForType(LoginController.class))
                .hasSize(1);
        assertThat(context.getBeanNamesForType(CurrentMemberController.class))
                .hasSize(1);
        assertThat(context.getBeanNamesForType(ProblemPostController.class))
                .hasSize(1);
        assertThat(context.getBeanNamesForType(
                ProblemPostPageController.class)).hasSize(1);
        assertThat(context.getBeanNamesForType(AttachmentController.class))
                .hasSize(1);
        assertThat(context.getBeanNamesForType(
                IntegratedPostController.class)).hasSize(1);
        assertThat(context.getBean(CreatePostUseCase.class))
                .isInstanceOf(CreatePostService.class);
    }
}