게시판 CRUD 웹

package board.crud;

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

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

package board.crud;

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

package board.crud;

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

public record CreatePostRequest(
        @NotBlank @Size(max = 80) String title,
        @NotBlank @Size(max = 720) String content) {
}

package board.crud;

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

public record ReplacePostRequest(
        @NotBlank @Size(max = 80) String title,
        @NotBlank @Size(max = 720) String content) {
}

package board.crud;

public record PostResponse(
        long id,
        String title,
        String content,
        long version) {

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

package board.crud;

import java.util.regex.Pattern;

final class PostEtag {
    private static final Pattern STRONG_TAG =
            Pattern.compile(
                    "\"post-([1-9][0-9]*)-v([1-9][0-9]*)\"");

    private PostEtag() {
    }

    static String format(Post post) {
        return "\"post-" + post.id()
                + "-v" + post.version() + "\"";
    }

    static long requireVersion(
            long resourceId,
            String rawIfMatch) {
        if (rawIfMatch == null) {
            throw new CrudFailures.InvalidIfMatch();
        }

        var matcher = STRONG_TAG.matcher(rawIfMatch);
        if (!matcher.matches()) {
            throw new CrudFailures.InvalidIfMatch();
        }

        try {
            var taggedId = Long.parseLong(matcher.group(1));
            var version = Long.parseLong(matcher.group(2));
            if (taggedId != resourceId) {
                throw new CrudFailures.InvalidIfMatch();
            }
            return version;
        } catch (NumberFormatException failure) {
            throw new CrudFailures.InvalidIfMatch();
        }
    }
}

package board.crud;

final class CrudFailures {
    private CrudFailures() {
    }

    static final class PostNotFound
            extends RuntimeException {
        PostNotFound(long id) {
            super("Post " + id + " was not found");
        }
    }

    static final class DuplicateTitle
            extends RuntimeException {
        DuplicateTitle(String title) {
            super("Post title already exists: " + title);
        }
    }

    static final class VersionMismatch
            extends RuntimeException {
        private final long expectedVersion;
        private final long currentVersion;

        VersionMismatch(
                long expectedVersion,
                long currentVersion) {
            super("Post version did not match");
            this.expectedVersion = expectedVersion;
            this.currentVersion = currentVersion;
        }

        long expectedVersion() {
            return expectedVersion;
        }

        long currentVersion() {
            return currentVersion;
        }
    }

    static final class InvalidIfMatch
            extends RuntimeException {
        InvalidIfMatch() {
            super("If-Match must contain one strong post tag");
        }
    }
}

package board.crud;

import java.util.concurrent.atomic.AtomicInteger;
import org.springframework.stereotype.Component;

@Component
final class CrudProbe {
    private final AtomicInteger replaceCalls =
            new AtomicInteger();

    void recordReplaceCall() {
        replaceCalls.incrementAndGet();
    }

    int replaceCalls() {
        return replaceCalls.get();
    }

    void reset() {
        replaceCalls.set(0);
    }
}

package board.crud;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.springframework.stereotype.Component;

@Component
final class VersionedPostStore {
    private final Map<Long, Post> posts =
            new LinkedHashMap<>();
    private long nextId = 1;

    synchronized Post create(
            String title,
            String content) {
        if (posts.values().stream()
                .anyMatch(post ->
                        post.title().equals(title))) {
            throw new CrudFailures.DuplicateTitle(title);
        }

        var id = nextId;
        nextId = Math.incrementExact(nextId);
        var created = new Post(
                id, title, content, 1);
        posts.put(id, created);
        return created;
    }

    synchronized List<Post> findAll() {
        return List.copyOf(posts.values());
    }

    synchronized Optional<Post> findById(long id) {
        return Optional.ofNullable(posts.get(id));
    }

    synchronized ReplaceResult replaceIfVersion(
            long id,
            long expectedVersion,
            String title,
            String content) {
        var current = posts.get(id);
        if (current == null) {
            return new Missing();
        }
        if (current.version() != expectedVersion) {
            return new Stale(current.version());
        }

        var replaced = new Post(
                id,
                title,
                content,
                Math.incrementExact(current.version()));
        posts.put(id, replaced);
        return new Replaced(replaced);
    }

    synchronized boolean delete(long id) {
        return posts.remove(id) != null;
    }

    synchronized void reset() {
        posts.clear();
        nextId = 1;
    }

    sealed interface ReplaceResult
            permits Replaced, Missing, Stale {
    }

    record Replaced(Post post)
            implements ReplaceResult {
    }

    record Missing()
            implements ReplaceResult {
    }

    record Stale(long currentVersion)
            implements ReplaceResult {
    }
}

package board.crud;

import java.util.List;
import org.springframework.stereotype.Service;

@Service
final class PostService {
    private final VersionedPostStore store;
    private final CrudProbe probe;

    PostService(
            VersionedPostStore store,
            CrudProbe probe) {
        this.store = store;
        this.probe = probe;
    }

    Post create(CreatePostRequest request) {
        return store.create(
                request.title(),
                request.content());
    }

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

    Post required(long id) {
        return store.findById(id)
                .orElseThrow(() ->
                        new CrudFailures.PostNotFound(id));
    }

    Post replace(
            long id,
            long expectedVersion,
            ReplacePostRequest request) {
        probe.recordReplaceCall();
        var result = store.replaceIfVersion(
                id,
                expectedVersion,
                request.title(),
                request.content());

        if (result instanceof
                VersionedPostStore.Replaced replaced) {
            return replaced.post();
        }
        if (result instanceof
                VersionedPostStore.Stale stale) {
            throw new CrudFailures.VersionMismatch(
                    expectedVersion,
                    stale.currentVersion());
        }
        throw new CrudFailures.PostNotFound(id);
    }

    void delete(long id) {
        if (!store.delete(id)) {
            throw new CrudFailures.PostNotFound(id);
        }
    }
}

package board.crud;

import jakarta.validation.Valid;
import java.net.URI;
import java.util.List;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/posts")
final class PostController {
    private final PostService service;

    PostController(PostService service) {
        this.service = service;
    }

    @PostMapping
    ResponseEntity<PostResponse> create(
            @Valid @RequestBody
                    CreatePostRequest request) {
        var created = service.create(request);
        return ResponseEntity
                .created(URI.create(
                        "/api/posts/" + created.id()))
                .eTag(PostEtag.format(created))
                .body(PostResponse.from(created));
    }

    @GetMapping
    List<PostResponse> list() {
        return service.findAll().stream()
                .map(PostResponse::from)
                .toList();
    }

    @GetMapping("/{id}")
    ResponseEntity<PostResponse> get(
            @PathVariable("id") long id) {
        var post = service.required(id);
        return ResponseEntity.ok()
                .eTag(PostEtag.format(post))
                .body(PostResponse.from(post));
    }

    @PutMapping("/{id}")
    ResponseEntity<PostResponse> replace(
            @PathVariable("id") long id,
            @RequestHeader(HttpHeaders.IF_MATCH)
                    String ifMatch,
            @Valid @RequestBody
                    ReplacePostRequest request) {
        var expectedVersion =
                PostEtag.requireVersion(id, ifMatch);
        var replaced = service.replace(
                id, expectedVersion, request);
        return ResponseEntity.ok()
                .eTag(PostEtag.format(replaced))
                .body(PostResponse.from(replaced));
    }

    @DeleteMapping("/{id}")
    ResponseEntity<Void> delete(
            @PathVariable("id") long id) {
        service.delete(id);
        return ResponseEntity.noContent().build();
    }
}

package board.crud;

import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice(
        assignableTypes = PostController.class)
final class CrudExceptionHandler {
    @ExceptionHandler(
            CrudFailures.PostNotFound.class)
    ResponseEntity<ProblemDetail> notFound(
            CrudFailures.PostNotFound failure) {
        return problem(
                HttpStatus.NOT_FOUND,
                "Post was not found",
                "POST_NOT_FOUND");
    }

    @ExceptionHandler(
            CrudFailures.DuplicateTitle.class)
    ResponseEntity<ProblemDetail> duplicateTitle(
            CrudFailures.DuplicateTitle failure) {
        return problem(
                HttpStatus.CONFLICT,
                "Post title already exists",
                "POST_TITLE_CONFLICT");
    }

    @ExceptionHandler(
            CrudFailures.VersionMismatch.class)
    ResponseEntity<ProblemDetail> versionMismatch(
            CrudFailures.VersionMismatch failure) {
        var body = ProblemDetail.forStatusAndDetail(
                HttpStatus.PRECONDITION_FAILED,
                "The post has changed");
        body.setProperty(
                "code", "POST_VERSION_MISMATCH");
        body.setProperty(
                "expectedVersion",
                failure.expectedVersion());
        body.setProperty(
                "currentVersion",
                failure.currentVersion());
        return ResponseEntity
                .status(HttpStatus.PRECONDITION_FAILED)
                .body(body);
    }

    @ExceptionHandler(
            CrudFailures.InvalidIfMatch.class)
    ResponseEntity<ProblemDetail> invalidIfMatch(
            CrudFailures.InvalidIfMatch failure) {
        return problem(
                HttpStatus.BAD_REQUEST,
                "If-Match is not supported by this API",
                "INVALID_IF_MATCH");
    }

    private static ResponseEntity<ProblemDetail> problem(
            HttpStatus status,
            String detail,
            String code) {
        var body = ProblemDetail.forStatusAndDetail(
                status, detail);
        body.setProperty("code", code);
        return ResponseEntity.status(status).body(body);
    }
}

package board.crud;

import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.Matchers.aMapWithSize;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.springframework.http.HttpHeaders.ETAG;
import static org.springframework.http.HttpHeaders.IF_MATCH;
import static org.springframework.http.HttpHeaders.LOCATION;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
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.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest(classes = CrudTestApplication.class)
@AutoConfigureMockMvc
class PostCrudContractTest {
    private static final String POST_1_V1 =
            "\"post-1-v1\"";

    @Autowired
    MockMvc mvc;

    @Autowired
    PostService service;

    @Autowired
    VersionedPostStore store;

    @Autowired
    CrudProbe probe;

    @BeforeEach
    void resetFixture() {
        store.reset();
        probe.reset();
    }

    @Test
    void create는_201_location_etag와_exact_body를_반환한다()
            throws Exception {
        mvc.perform(post("/api/posts")
                        .contentType(APPLICATION_JSON)
                        .content(json(
                                "HTTP contract",
                                "create body")))
                .andExpect(status().isCreated())
                .andExpect(header().string(
                        LOCATION, "/api/posts/1"))
                .andExpect(header().string(
                        ETAG, POST_1_V1))
                .andExpect(jsonPath(
                        "$", aMapWithSize(4)))
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.title")
                        .value("HTTP contract"))
                .andExpect(jsonPath("$.content")
                        .value("create body"))
                .andExpect(jsonPath("$.version")
                        .value(1));
    }

    @Test
    void collection_get은_저장_순서의_body를_반환한다()
            throws Exception {
        service.create(new CreatePostRequest(
                "first", "one"));
        service.create(new CreatePostRequest(
                "second", "two"));

        mvc.perform(get("/api/posts"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$", hasSize(2)))
                .andExpect(jsonPath("$[0].id").value(1))
                .andExpect(jsonPath("$[0].title")
                        .value("first"))
                .andExpect(jsonPath("$[1].id").value(2))
                .andExpect(jsonPath("$[1].title")
                        .value("second"));
    }

    @Test
    void item_get은_200_etag와_exact_body를_반환한다()
            throws Exception {
        service.create(new CreatePostRequest(
                "read", "current body"));

        mvc.perform(get("/api/posts/1"))
                .andExpect(status().isOk())
                .andExpect(header().string(
                        ETAG, POST_1_V1))
                .andExpect(jsonPath(
                        "$", aMapWithSize(4)))
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.title")
                        .value("read"))
                .andExpect(jsonPath("$.content")
                        .value("current body"))
                .andExpect(jsonPath("$.version")
                        .value(1));
    }

    @Test
    void current_if_match는_200_new_etag와_교체_body를_반환한다()
            throws Exception {
        service.create(new CreatePostRequest(
                "before", "old body"));

        mvc.perform(put("/api/posts/1")
                        .header(IF_MATCH, POST_1_V1)
                        .contentType(APPLICATION_JSON)
                        .content(json(
                                "after",
                                "new body")))
                .andExpect(status().isOk())
                .andExpect(header().string(
                        ETAG, "\"post-1-v2\""))
                .andExpect(jsonPath(
                        "$", aMapWithSize(4)))
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.title")
                        .value("after"))
                .andExpect(jsonPath("$.content")
                        .value("new body"))
                .andExpect(jsonPath("$.version")
                        .value(2));
    }

    @Test
    void stale_if_match는_412이고_저장값을_보존한다()
            throws Exception {
        service.create(new CreatePostRequest(
                "before", "version one"));
        service.replace(
                1,
                1,
                new ReplacePostRequest(
                        "winner", "version two"));
        probe.reset();

        mvc.perform(put("/api/posts/1")
                        .header(IF_MATCH, POST_1_V1)
                        .contentType(APPLICATION_JSON)
                        .content(json(
                                "stale",
                                "must not win")))
                .andExpect(status()
                        .isPreconditionFailed())
                .andExpect(jsonPath("$.code")
                        .value(
                                "POST_VERSION_MISMATCH"))
                .andExpect(jsonPath(
                        "$.expectedVersion").value(1))
                .andExpect(jsonPath(
                        "$.currentVersion").value(2));

        var current = service.required(1);
        assertEquals("winner", current.title());
        assertEquals("version two", current.content());
        assertEquals(2, current.version());
        assertEquals(1, probe.replaceCalls());
    }

    @Test
    void missing_item_put은_404를_반환한다()
            throws Exception {
        mvc.perform(put("/api/posts/99")
                        .header(
                                IF_MATCH,
                                "\"post-99-v1\"")
                        .contentType(APPLICATION_JSON)
                        .content(json(
                                "missing",
                                "body")))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.code")
                        .value("POST_NOT_FOUND"));
    }

    @Test
    void invalid_if_match는_400이고_service에_진입하지_않는다()
            throws Exception {
        var requestBody = json("title", "body");

        mvc.perform(put("/api/posts/1")
                        .contentType(APPLICATION_JSON)
                        .content(requestBody))
                .andExpect(status().isBadRequest());

        for (var invalid : List.of(
                "post-1-v1",
                "W/\"post-1-v1\"",
                "*",
                "\"post-2-v1\"",
                "\"post-1-v0\"",
                "\"post-1-v1\", \"post-1-v2\"")) {
            mvc.perform(put("/api/posts/1")
                            .header(IF_MATCH, invalid)
                            .contentType(
                                    APPLICATION_JSON)
                            .content(requestBody))
                    .andExpect(status().isBadRequest())
                    .andExpect(jsonPath("$.code")
                            .value(
                                    "INVALID_IF_MATCH"));
        }

        assertEquals(0, probe.replaceCalls());
    }

    @Test
    void duplicate_title_create는_409를_반환한다()
            throws Exception {
        mvc.perform(post("/api/posts")
                        .contentType(APPLICATION_JSON)
                        .content(json(
                                "same", "first")))
                .andExpect(status().isCreated());

        mvc.perform(post("/api/posts")
                        .contentType(APPLICATION_JSON)
                        .content(json(
                                "same", "second")))
                .andExpect(status().isConflict())
                .andExpect(jsonPath("$.code")
                        .value(
                                "POST_TITLE_CONFLICT"));
    }

    @Test
    void delete는_204_empty이고_repeat는_404이다()
            throws Exception {
        service.create(new CreatePostRequest(
                "delete", "body"));

        mvc.perform(delete("/api/posts/1"))
                .andExpect(status().isNoContent())
                .andExpect(content().string(""));

        mvc.perform(delete("/api/posts/1"))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.code")
                        .value("POST_NOT_FOUND"));
    }

    @Test
    void missing_item_get은_404를_반환한다()
            throws Exception {
        mvc.perform(get("/api/posts/1"))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.code")
                        .value("POST_NOT_FOUND"));
    }

    @Test
    void same_version_concurrency는_하나만_교체한다()
            throws Exception {
        service.create(new CreatePostRequest(
                "before", "version one"));
        var start = new CountDownLatch(1);
        var pool = Executors.newFixedThreadPool(2);

        try {
            var first = pool.submit(replaceAfter(
                    start, "first winner"));
            var second = pool.submit(replaceAfter(
                    start, "second winner"));
            start.countDown();

            var outcomes = List.of(
                    first.get(3, SECONDS),
                    second.get(3, SECONDS));

            assertEquals(
                    1,
                    outcomes.stream()
                            .filter(Post.class::isInstance)
                            .count());
            assertEquals(
                    1,
                    outcomes.stream()
                            .filter(
                                    CrudFailures
                                            .VersionMismatch
                                            .class
                                            ::isInstance)
                            .count());
            assertInstanceOf(
                    CrudFailures.VersionMismatch.class,
                    outcomes.stream()
                            .filter(
                                    CrudFailures
                                            .VersionMismatch
                                            .class
                                            ::isInstance)
                            .findFirst()
                            .orElseThrow());

            var current = service.required(1);
            assertEquals(2, current.version());
            assertTrue(Set.of(
                            "first winner",
                            "second winner")
                    .contains(current.content()));
            assertEquals(2, probe.replaceCalls());
        } finally {
            pool.shutdownNow();
            assertTrue(pool.awaitTermination(
                    3, SECONDS));
        }
    }

    private Callable<Object> replaceAfter(
            CountDownLatch start,
            String content) {
        return () -> {
            if (!start.await(3, SECONDS)) {
                throw new IllegalStateException(
                        "Concurrent start timed out");
            }
            try {
                return service.replace(
                        1,
                        1,
                        new ReplacePostRequest(
                                "winner", content));
            } catch (
                    CrudFailures.VersionMismatch
                            failure) {
                return failure;
            }
        };
    }

    private static String json(
            String title,
            String content) {
        return """
                {
                  "title": "%s",
                  "content": "%s"
                }
                """.formatted(title, content);
    }
}