14주차 코드 — 핵심 회귀 smoke와 SQL 연결·원장 수 점검

package com.example.financialcore;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.simple.JdbcClient;

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

@SpringBootTest
class CoreSchemaIT extends PostgresIntegrationTestSupport {
    @Autowired JdbcClient jdbc;

    @Test
    void v001CreatesExactlyTheRequiredCoreTables() {
        var tables = jdbc.sql("""
                SELECT table_name FROM information_schema.tables
                WHERE table_schema='public' AND table_type='BASE TABLE'
                  AND table_name <> 'flyway_schema_history'
                ORDER BY table_name
                """).query(String.class).list();
        assertThat(tables)
            .as("W6D1_RED_EXPECTED_FOUR_CORE_TABLES")
            .containsExactlyInAnyOrder("account", "business_tx", "ledger_entry", "idempotency_request");
    }
}

package com.example.financialcore.account;

import com.example.financialcore.PostgresIntegrationTestSupport;
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.jdbc.core.simple.JdbcClient;

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

@SpringBootTest
class OpeningIntegrationTest extends PostgresIntegrationTestSupport {
    @Autowired JdbcClient jdbc;
    @Autowired AccountOpeningService openings;

    @BeforeEach
    void clean() {
        jdbc.sql("TRUNCATE idempotency_request,ledger_entry,business_tx,account RESTART IDENTITY CASCADE").update();
    }

    @Test
    void openingWritesAccountBusinessTransactionAndLedgerAtomically() {
        var account = openings.open("customer-1", "OPEN-100", 12_345);
        assertThat(jdbc.sql("SELECT COUNT(*) FROM account WHERE id=:id")
            .param("id", account.getId()).query(Long.class).single()).isEqualTo(1);
        assertThat(jdbc.sql("SELECT COUNT(*) FROM business_tx WHERE tx_type='OPENING'")
            .query(Long.class).single()).isEqualTo(1);
        assertThat(jdbc.sql("SELECT COUNT(*) FROM ledger_entry WHERE account_id=:id AND entry_type='OPENING'")
            .param("id", account.getId()).query(Long.class).single())
            .as("W6D3_RED_EXPECTED_OPENING_LEDGER")
            .isEqualTo(1);
    }
}

package com.example.financialcore.account.api;

import com.example.financialcore.PostgresIntegrationTestSupport;
import com.example.financialcore.account.AccountService;
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.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.test.web.servlet.MockMvc;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.httpBasic;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

@SpringBootTest
@AutoConfigureMockMvc
class AccountControllerTest extends PostgresIntegrationTestSupport {
    @Autowired MockMvc mvc;
    @Autowired JdbcClient jdbc;
    @Autowired AccountService service;

    @BeforeEach void clean() {
        jdbc.sql("TRUNCATE idempotency_request,ledger_entry,business_tx,account RESTART IDENTITY CASCADE").update();
    }

    @Test
    void createReturns201AndPersistsOpening() throws Exception {
        var response = mvc.perform(post("/api/accounts")
                .with(httpBasic("customer-1", "password"))
                .contentType("application/json")
                .content("{\"accountNo\":\"A-100\",\"openingBalance\":10000}"))
            .andReturn().getResponse();
        assertThat(response.getStatus()).isEqualTo(201);
        assertThat(jdbc.sql("SELECT COUNT(*) FROM account WHERE account_no='A-100'")
            .query(Long.class).single()).isEqualTo(1);
    }

    @Test
    void negativeOpeningReturns400AndWritesNothing() throws Exception {
        var response = mvc.perform(post("/api/accounts")
                .with(httpBasic("customer-1", "password"))
                .header("X-Request-Id", "w6-invalid")
                .contentType("application/json")
                .content("{\"accountNo\":\"BAD\",\"openingBalance\":-1}"))
            .andReturn().getResponse();
        assertThat(response.getStatus()).isEqualTo(400);
        assertThat(response.getContentAsString()).contains("INVALID_REQUEST", "w6-invalid");
        assertThat(jdbc.sql("SELECT COUNT(*) FROM account").query(Long.class).single()).isZero();
    }

    @Test
    void ownerReadsAccount() throws Exception {
        var account = service.create("customer-1", "LOOKUP", 7_000);
        var response = mvc.perform(get("/api/accounts/{id}", account.getId())
                .with(httpBasic("customer-1", "password")))
            .andReturn().getResponse();
        assertThat(response.getStatus()).isEqualTo(200);
        assertThat(response.getContentAsString()).contains("LOOKUP");
    }

    @Test
    void missingAccountReturns404() throws Exception {
        var response = mvc.perform(get("/api/accounts/999999")
                .with(httpBasic("customer-1", "password"))
                .header("X-Request-Id", "w6-missing"))
            .andReturn().getResponse();
        assertThat(response.getStatus()).isEqualTo(404);
        assertThat(response.getContentAsString()).contains("ACCOUNT_NOT_FOUND", "w6-missing");
    }
}

package com.example.financialcore.transfer;

import com.example.financialcore.PostgresIntegrationTestSupport;
import com.example.financialcore.account.Account;
import com.example.financialcore.account.AccountOpeningService;
import com.example.financialcore.account.AccountRepository;
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.jdbc.core.simple.JdbcClient;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

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

@SpringBootTest
class SortedLockTransferIT extends PostgresIntegrationTestSupport {
    @Autowired JdbcClient jdbc;
    @Autowired AccountOpeningService openings;
    @Autowired AccountRepository accounts;
    @Autowired TransferService transfers;
    Account first;
    Account second;

    @BeforeEach
    void setUp() {
        jdbc.sql("TRUNCATE idempotency_request,ledger_entry,business_tx,account RESTART IDENTITY CASCADE")
            .update();
        first = openings.open("customer-1", "SORT-A", 10_000);
        second = openings.open("customer-1", "SORT-B", 10_000);
    }

    @Test
    void oppositeDirectionsFinishWithoutDeadlockAndPreserveTotal() throws Exception {
        int pairs = 10;
        int tasks = pairs * 2;
        var ready = new CountDownLatch(tasks);
        var start = new CountDownLatch(1);
        var pool = Executors.newFixedThreadPool(tasks);
        try {
            List<Future<?>> futures = new ArrayList<>();
            for (int i = 0; i < pairs; i++) {
                int sequence = i;
                futures.add(pool.submit(() -> invoke(ready, start, "ab-" + sequence,
                    first.getId(), second.getId())));
                futures.add(pool.submit(() -> invoke(ready, start, "ba-" + sequence,
                    second.getId(), first.getId())));
            }
            assertThat(ready.await(10, TimeUnit.SECONDS)).isTrue();
            start.countDown();
            for (Future<?> future : futures) future.get(30, TimeUnit.SECONDS);
            long firstBalance = accounts.findById(first.getId()).orElseThrow().getBalance();
            long secondBalance = accounts.findById(second.getId()).orElseThrow().getBalance();
            assertThat(firstBalance + secondBalance).isEqualTo(20_000);
            assertThat(jdbc.sql("SELECT COALESCE(SUM(signed_amount),0) FROM ledger_entry WHERE entry_type LIKE 'TRANSFER_%'")
                .query(Long.class).single()).isZero();
        } finally {
            start.countDown();
            pool.shutdownNow();
        }
    }

    private Object invoke(
        CountDownLatch ready, CountDownLatch start, String key, long from, long to
    ) {
        try {
            ready.countDown();
            start.await();
            return transfers.transfer(new TransferService.Command("customer-1", key, from, to, 100));
        } catch (InterruptedException interrupted) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException(interrupted);
        }
    }
}