감사 로그와 독립 커밋

package board.tx.propagation.outbox;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

import javax.sql.DataSource;

import org.h2.jdbcx.JdbcDataSource;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;

class TransactionalOutboxAuditTest {
    private AnnotationConfigApplicationContext context;
    private JdbcTemplate jdbc;

    @BeforeEach
    void openContext() {
        context = new AnnotationConfigApplicationContext(Config.class);
        jdbc = context.getBean(JdbcTemplate.class);
        jdbc.execute("drop table if exists audit_log");
        jdbc.execute("drop table if exists audit_inbox");
        jdbc.execute("drop table if exists outbox");
        jdbc.execute("drop table if exists posts");
        jdbc.execute("create table posts(id bigint primary key, title varchar(120))");
        jdbc.execute("create table outbox("
                + "event_id varchar(48) primary key, "
                + "aggregate_id bigint not null, "
                + "event_type varchar(48) not null)");
        jdbc.execute("create table audit_inbox(event_id varchar(48) primary key)");
        jdbc.execute("create table audit_log("
                + "event_id varchar(48) primary key, summary varchar(160) not null)");
    }

    @AfterEach
    void closeContext() {
        context.close();
    }

    @Test
    void businessRowAndOutboxCommitOrRollbackTogether() {
        var business = context.getBean(PostCreation.class);

        assertThrows(
                ExpectedBusinessFailure.class,
                () -> business.create(41L, "failed", "evt-41", true));
        assertEquals(0, count("posts"));
        assertEquals(0, count("outbox"));

        business.create(42L, "committed", "evt-42", false);
        assertEquals(1, count("posts"));
        assertEquals(1, count("outbox"));
    }

    @Test
    void duplicateDeliveryProjectsOneAuditEffect() {
        context.getBean(PostCreation.class)
                .create(51L, "once", "evt-51", false);
        var relay = context.getBean(OutboxRelay.class);

        relay.deliver("evt-51");
        relay.deliver("evt-51");

        assertEquals(1, count("audit_inbox"));
        assertEquals(1, count("audit_log"));
    }

    private int count(String table) {
        return jdbc.queryForObject(
                "select count(*) from " + table,
                Integer.class);
    }

    record OutboxEvent(String eventId, long aggregateId, String eventType) { }

    public static class PostCreation {
        private final JdbcTemplate jdbc;

        PostCreation(JdbcTemplate jdbc) {
            this.jdbc = jdbc;
        }

        @Transactional
        public void create(
                long postId,
                String title,
                String eventId,
                boolean failBeforeCommit
        ) {
            jdbc.update(
                    "insert into posts(id, title) values (?, ?)",
                    postId,
                    title);
            jdbc.update(
                    "insert into outbox(event_id, aggregate_id, event_type) "
                            + "values (?, ?, 'PostCreated')",
                    eventId,
                    postId);
            if (failBeforeCommit) {
                throw new ExpectedBusinessFailure();
            }
        }
    }

    public static class AuditProjector {
        private final JdbcTemplate jdbc;

        AuditProjector(JdbcTemplate jdbc) {
            this.jdbc = jdbc;
        }

        @Transactional
        public void project(OutboxEvent event) {
            jdbc.update(
                    "insert into audit_inbox(event_id) values (?)",
                    event.eventId());
            jdbc.update(
                    "insert into audit_log(event_id, summary) values (?, ?)",
                    event.eventId(),
                    event.eventType() + ":post-" + event.aggregateId());
        }
    }

    public static class OutboxRelay {
        private final JdbcTemplate jdbc;
        private final AuditProjector projector;

        OutboxRelay(JdbcTemplate jdbc, AuditProjector projector) {
            this.jdbc = jdbc;
            this.projector = projector;
        }

        public void deliver(String eventId) {
            OutboxEvent event = jdbc.queryForObject(
                    "select event_id, aggregate_id, event_type "
                            + "from outbox where event_id = ?",
                    (resultSet, rowNumber) -> new OutboxEvent(
                            resultSet.getString("event_id"),
                            resultSet.getLong("aggregate_id"),
                            resultSet.getString("event_type")),
                    eventId);
            try {
                projector.project(event);
            } catch (DuplicateKeyException alreadyProjected) {
                // The projector transaction has already rolled back cleanly.
            }
        }
    }

    static final class ExpectedBusinessFailure extends RuntimeException {
        private static final long serialVersionUID = 1L;
    }

    @Configuration
    @EnableTransactionManagement(proxyTargetClass = true)
    static class Config {
        @Bean
        DataSource dataSource() {
            var source = new JdbcDataSource();
            source.setURL("jdbc:h2:mem:b92_outbox;DB_CLOSE_DELAY=-1");
            return source;
        }

        @Bean
        PlatformTransactionManager transactionManager(DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }

        @Bean
        JdbcTemplate jdbcTemplate(DataSource dataSource) {
            return new JdbcTemplate(dataSource);
        }

        @Bean
        PostCreation postCreation(JdbcTemplate jdbc) {
            return new PostCreation(jdbc);
        }

        @Bean
        AuditProjector auditProjector(JdbcTemplate jdbc) {
            return new AuditProjector(jdbc);
        }

        @Bean
        OutboxRelay outboxRelay(JdbcTemplate jdbc, AuditProjector projector) {
            return new OutboxRelay(jdbc, projector);
        }
    }
}