트랜잭션 전파 규칙

package board.tx.propagation.required;

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.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.UnexpectedRollbackException;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

class RequiredAndNestedBoundaryTest {
    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 tx_note");
        jdbc.execute("create table tx_note(id bigint primary key, phase varchar(24))");
    }

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

    @Test
    void requiredRollbackOnlyFailsAtTheOuterCompletionBoundary() {
        var outer = context.getBean(OuterWork.class);

        assertThrows(
                UnexpectedRollbackException.class,
                () -> outer.requiredThenRecover(10L));
        assertEquals(0, jdbc.queryForObject(
                "select count(*) from tx_note", Integer.class));
    }

    @Test
    void nestedFailureRollsBackToSavepointAndOuterCanCommit() {
        context.getBean(OuterWork.class).nestedThenContinue(20L);

        assertEquals(
                java.util.List.of("outer", "after"),
                jdbc.queryForList(
                        "select phase from tx_note order by id", String.class));
    }

    public static class RequiredStep {
        private final JdbcTemplate jdbc;

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

        @Transactional
        public void writeThenFail(long id) {
            jdbc.update(
                    "insert into tx_note(id, phase) values (?, 'required-inner')",
                    id);
            throw new ExpectedStepFailure();
        }
    }

    public static class NestedStep {
        private final JdbcTemplate jdbc;

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

        @Transactional(propagation = Propagation.NESTED)
        public void writeThenFail(long id) {
            jdbc.update(
                    "insert into tx_note(id, phase) values (?, 'nested-inner')",
                    id);
            throw new ExpectedStepFailure();
        }
    }

    public static class OuterWork {
        private final JdbcTemplate jdbc;
        private final RequiredStep required;
        private final NestedStep nested;

        OuterWork(JdbcTemplate jdbc, RequiredStep required, NestedStep nested) {
            this.jdbc = jdbc;
            this.required = required;
            this.nested = nested;
        }

        @Transactional
        public void requiredThenRecover(long id) {
            jdbc.update(
                    "insert into tx_note(id, phase) values (?, 'outer')", id);
            try {
                required.writeThenFail(id + 1);
            } catch (ExpectedStepFailure expected) {
                // The exception is handled, but the shared physical transaction
                // remains rollback-only.
            }
        }

        @Transactional
        public void nestedThenContinue(long id) {
            jdbc.update(
                    "insert into tx_note(id, phase) values (?, 'outer')", id);
            try {
                nested.writeThenFail(id + 1);
            } catch (ExpectedStepFailure expected) {
                jdbc.update(
                        "insert into tx_note(id, phase) values (?, 'after')",
                        id + 2);
            }
        }
    }

    static final class ExpectedStepFailure 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_required;DB_CLOSE_DELAY=-1");
            return source;
        }

        @Bean
        PlatformTransactionManager transactionManager(DataSource dataSource) {
            var manager = new DataSourceTransactionManager(dataSource);
            manager.setNestedTransactionAllowed(true);
            return manager;
        }

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

        @Bean
        RequiredStep requiredStep(JdbcTemplate jdbc) {
            return new RequiredStep(jdbc);
        }

        @Bean
        NestedStep nestedStep(JdbcTemplate jdbc) {
            return new NestedStep(jdbc);
        }

        @Bean
        OuterWork outerWork(
                JdbcTemplate jdbc,
                RequiredStep required,
                NestedStep nested
        ) {
            return new OuterWork(jdbc, required, nested);
        }
    }
}