REQUIRES_NEW의 독립 자원

package board.tx.propagation.requiresnew;

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

import java.sql.Connection;
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.jdbc.core.ConnectionCallback;
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.Propagation;
import org.springframework.transaction.annotation.Transactional;

class RequiresNewResourceTest {
    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 posts");
        jdbc.execute("create table posts(id bigint primary key)");
        jdbc.execute("create table audit_log(id bigint primary key, outcome varchar(24))");
    }

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

    @Test
    void requiresNewUsesAnotherConnectionAndCommitsIndependently() {
        var observation = context.getBean(ConnectionObservation.class);

        assertThrows(
                ExpectedOuterFailure.class,
                () -> context.getBean(OuterWork.class).writeAuditThenFail(41L));

        assertNotSame(observation.outerConnection, observation.innerConnection);
        assertEquals(0, observation.outerRowsVisibleToInner);
        assertEquals(0, jdbc.queryForObject(
                "select count(*) from posts", Integer.class));
        assertEquals(1, jdbc.queryForObject(
                "select count(*) from audit_log", Integer.class));
    }

    @Test
    void poolBudgetIncludesEveryHeldOuterAndInnerConnection() {
        assertEquals(52, new PoolBudget(24, 1, 4).pessimisticMinimum());

        int demand = new PoolBudget(40, 1, 6).pessimisticMinimum();
        assertEquals(86, demand);
        assertTrue(demand > 70, "the database limit requires a redesign");
    }

    record PoolBudget(
            int concurrentOuterTransactions,
            int maximumRequiresNewDepth,
            int reservedConnections
    ) {
        PoolBudget {
            if (concurrentOuterTransactions < 1
                    || maximumRequiresNewDepth < 0
                    || reservedConnections < 0) {
                throw new IllegalArgumentException("invalid pool inputs");
            }
        }

        int pessimisticMinimum() {
            return Math.addExact(
                    Math.multiplyExact(
                            concurrentOuterTransactions,
                            1 + maximumRequiresNewDepth),
                    reservedConnections);
        }
    }

    public static class ConnectionObservation {
        private Connection outerConnection;
        private Connection innerConnection;
        private int outerRowsVisibleToInner;
    }

    public static class IndependentAudit {
        private final JdbcTemplate jdbc;
        private final ConnectionObservation observation;

        IndependentAudit(JdbcTemplate jdbc, ConnectionObservation observation) {
            this.jdbc = jdbc;
            this.observation = observation;
        }

        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void record(long id) {
            observation.innerConnection = currentConnection(jdbc);
            observation.outerRowsVisibleToInner = jdbc.queryForObject(
                    "select count(*) from posts where id = ?",
                    Integer.class,
                    id);
            jdbc.update(
                    "insert into audit_log(id, outcome) values (?, 'ATTEMPTED')",
                    id);
        }
    }

    public static class OuterWork {
        private final JdbcTemplate jdbc;
        private final IndependentAudit audit;
        private final ConnectionObservation observation;

        OuterWork(
                JdbcTemplate jdbc,
                IndependentAudit audit,
                ConnectionObservation observation
        ) {
            this.jdbc = jdbc;
            this.audit = audit;
            this.observation = observation;
        }

        @Transactional
        public void writeAuditThenFail(long id) {
            observation.outerConnection = currentConnection(jdbc);
            jdbc.update("insert into posts(id) values (?)", id);
            audit.record(id);
            throw new ExpectedOuterFailure();
        }
    }

    static Connection currentConnection(JdbcTemplate jdbc) {
        Connection connection = jdbc.execute(
                (ConnectionCallback<Connection>) current -> current);
        if (connection == null) {
            throw new IllegalStateException("connection callback returned null");
        }
        return connection;
    }

    static final class ExpectedOuterFailure 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_requires_new;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
        ConnectionObservation connectionObservation() {
            return new ConnectionObservation();
        }

        @Bean
        IndependentAudit independentAudit(
                JdbcTemplate jdbc,
                ConnectionObservation observation
        ) {
            return new IndependentAudit(jdbc, observation);
        }

        @Bean
        OuterWork outerWork(
                JdbcTemplate jdbc,
                IndependentAudit audit,
                ConnectionObservation observation
        ) {
            return new OuterWork(jdbc, audit, observation);
        }
    }
}