저장소·서비스 테스트

package board.domain;

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

public interface PostRepository {
    Post save(PostDraft draft);
    Optional<Post> findById(long id);
    List<Post> findAll();
    boolean existsByAuthorIdAndTitleAndPublishedOn(
            String authorId,
            String title,
            LocalDate publishedOn);
}

package board.infrastructure;

import board.domain.PostDraft;
import board.domain.PostRepository;
import board.domain.Post;

import java.time.LocalDate;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public final class MemoryPostRepository implements PostRepository {
    private final AtomicLong sequence = new AtomicLong();
    private final ConcurrentHashMap<Long, Post> store =
            new ConcurrentHashMap<>();

    @Override
    public Post save(PostDraft draft) {
        if (draft == null) {
            throw new IllegalArgumentException("draft is required");
        }
        var id = sequence.incrementAndGet();
        var saved = Post.saved(id, draft);
        store.put(id, saved);
        return saved;
    }

    @Override
    public Optional<Post> findById(long id) {
        return Optional.ofNullable(store.get(id));
    }

    @Override
    public List<Post> findAll() {
        return store.values().stream()
                .sorted(Comparator.comparingLong(Post::id))
                .toList();
    }

    @Override
    public boolean existsByAuthorIdAndTitleAndPublishedOn(
            String authorId,
            String title,
            LocalDate publishedOn
    ) {
        return store.values().stream().anyMatch(post ->
                post.authorId().equals(authorId)
                        && post.title().equals(title)
                        && post.publishedOn().equals(publishedOn));
    }
}

package board.application;

import java.time.LocalDate;

public record CreatePostCommand(
        String authorId,
        String title,
        String content,
        LocalDate publishedOn
) {}

package board.application;

public final class DuplicatePostException extends RuntimeException {
    public DuplicatePostException(String authorId, String title) {
        super("post already exists: member=%s title=%s"
                .formatted(authorId, title));
    }
}

package board.application;

public final class PostNotFoundException extends RuntimeException {
    public PostNotFoundException(long id) {
        super("post not found: " + id);
    }
}

package board.application;

import board.domain.PostDraft;
import board.domain.PostRepository;
import board.domain.Post;

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

public final class PostService {
    private final PostRepository repository;
    private final Clock clock;

    public PostService(PostRepository repository, Clock clock) {
        this.repository = Objects.requireNonNull(
                repository, "repository");
        this.clock = Objects.requireNonNull(clock, "clock");
    }

    public Post register(CreatePostCommand command) {
        Objects.requireNonNull(command, "command");
        var draft = new PostDraft(
                command.authorId(),
                command.title(),
                command.content(),
                command.publishedOn());
        var today = LocalDate.now(clock);
        draft.validateDate(today);

        if (repository.existsByAuthorIdAndTitleAndPublishedOn(
                draft.authorId(), draft.title(), draft.publishedOn())) {
            throw new DuplicatePostException(
                    draft.authorId(), draft.title());
        }
        return repository.save(draft);
    }

    public Post find(long id) {
        return repository.findById(id)
                .orElseThrow(() -> new PostNotFoundException(id));
    }

    public List<Post> findAll() {
        return repository.findAll();
    }
}

package board.infrastructure;

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

import java.time.LocalDate;
import org.junit.jupiter.api.Test;
import board.domain.PostDraft;

class MemoryPostRepositoryTest {
    private final MemoryPostRepository repository =
            new MemoryPostRepository();

    @Test
    void 저장할_때_식별자를_부여하고_다시_조회한다() {
        var draft = new PostDraft(
                "member-1", "Spring", "Spring 빈 구성을 정리합니다.",
                LocalDate.of(2026, 7, 13));

        var saved = repository.save(draft);

        assertThat(saved.id()).isPositive();
        assertThat(repository.findById(saved.id())).contains(saved);
    }

    @Test
    void 목록은_식별자_순서로_반환한다() {
        var day = LocalDate.of(2026, 7, 13);
        repository.save(new PostDraft(
                "member-1", "Java", "Java 객체 모델을 정리합니다.", day));
        repository.save(new PostDraft(
                "member-1", "HTTP", "HTTP 요청 흐름을 정리합니다.", day));

        assertThat(repository.findAll())
                .extracting("title")
                .containsExactly("Java", "HTTP");
    }
}

package board.application;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import board.domain.Post;
import board.domain.PostDraft;
import board.domain.PostRepository;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneOffset;
import org.junit.jupiter.api.Test;

class PostServiceTest {
    private final LocalDate today = LocalDate.of(2026, 7, 13);
    private final Clock clock = Clock.fixed(
            Instant.parse("2026-07-13T09:00:00Z"),
            ZoneOffset.UTC);
    private final PostRepository repository =
            mock(PostRepository.class);
    private final PostService service = new PostService(
            repository, clock);

    @Test
    void 미래_작성일은_저장소와_상호작용하기_전에_거부한다() {
        var command = new CreatePostCommand(
                "member-1", "Spring", "Spring MVC를 정리합니다.",
                today.plusDays(1));

        assertThatThrownBy(() -> service.register(command))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("publishedOn must not be in the future");
        verifyNoInteractions(repository);
    }

    @Test
    void 정규화한_키가_중복이면_저장하지_않는다() {
        var command = new CreatePostCommand(
                " member-1 ", " Spring ",
                " Spring MVC를 정리합니다. ", today);
        when(repository.existsByAuthorIdAndTitleAndPublishedOn(
                "member-1", "Spring", today)).thenReturn(true);

        assertThatThrownBy(() -> service.register(command))
                .isInstanceOf(DuplicatePostException.class)
                .hasMessageContaining("member-1")
                .hasMessageContaining("Spring");
        verify(repository)
                .existsByAuthorIdAndTitleAndPublishedOn(
                        "member-1", "Spring", today);
        verify(repository, never()).save(any(PostDraft.class));
        verifyNoMoreInteractions(repository);
    }

    @Test
    void 중복_확인_후_저장한다() {
        var command = new CreatePostCommand(
                " member-1 ", " Spring ",
                " Spring MVC를 정리합니다. ", today);
        var draft = new PostDraft(
                "member-1", "Spring",
                "Spring MVC를 정리합니다.", today);
        var saved = Post.saved(1, draft);
        when(repository.existsByAuthorIdAndTitleAndPublishedOn(
                "member-1", "Spring", today)).thenReturn(false);
        when(repository.save(draft)).thenReturn(saved);

        assertThat(service.register(command)).isEqualTo(saved);

        var order = inOrder(repository);
        order.verify(repository)
                .existsByAuthorIdAndTitleAndPublishedOn(
                        "member-1", "Spring", today);
        order.verify(repository).save(draft);
        verifyNoMoreInteractions(repository);
    }
}

./gradlew test --tests 'board.infrastructure*' --tests 'board.application*'

private static final AtomicLong sequence = new AtomicLong();
private static final ConcurrentHashMap<Long, Post> store =
        new ConcurrentHashMap<>();