롤백 규칙

package board.tx.proxy.rollback;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;

public class RollbackPolicyService {
    private final JdbcTemplate jdbc;

    public RollbackPolicyService(DataSource dataSource) {
        this.jdbc = new JdbcTemplate(dataSource);
    }

    @Transactional
    public void defaultChecked(long id) throws ReportExportFailure {
        insert(id, "default-checked");
        throw new ReportExportFailure();
    }

    @Transactional
    public void defaultRuntime(long id) {
        insert(id, "default-runtime");
        throw new NotificationFailure();
    }

    @Transactional
    public void defaultError(long id) {
        insert(id, "default-error");
        throw new AssertionError("broken invariant");
    }

    @Transactional(rollbackFor = ReportExportFailure.class)
    public void rollbackChecked(long id) throws ReportExportFailure {
        insert(id, "rollback-checked");
        throw new ReportExportFailure();
    }

    @Transactional(noRollbackFor = NotificationFailure.class)
    public void commitRuntime(long id) {
        insert(id, "commit-runtime");
        throw new NotificationFailure();
    }

    @Transactional(
            rollbackFor = Exception.class,
            noRollbackFor = NotificationFailure.class
    )
    public void specificNoRollbackWins(long id) {
        insert(id, "specific-no-rollback");
        throw new NotificationFailure();
    }

    @Transactional
    public boolean catchRuntimeAndReturn(long id) {
        insert(id, "caught-runtime");
        try {
            throw new NotificationFailure();
        } catch (NotificationFailure handled) {
            return false;
        }
    }

    private void insert(long id, String scenario) {
        jdbc.update(
                "insert into rollback_note(id, scenario) values (?, ?)",
                id,
                scenario
        );
    }

    public static final class ReportExportFailure extends Exception {
        public ReportExportFailure() {
            super("report export failed");
        }
    }

    public static final class NotificationFailure extends RuntimeException {
        public NotificationFailure() {
            super("notification failed");
        }
    }
}

package board.tx.proxy.rollback;

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

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.aop.support.AopUtils;
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.annotation.EnableTransactionManagement;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;

class RollbackPolicyTest {
    private AnnotationConfigApplicationContext context;
    private JdbcTemplate jdbc;
    private RollbackPolicyService service;

    @BeforeEach
    void openContext() {
        context = new AnnotationConfigApplicationContext(RollbackConfig.class);
        var dataSource = context.getBean(DataSource.class);
        jdbc = new JdbcTemplate(dataSource);
        jdbc.execute("create table if not exists rollback_note(id bigint primary key, scenario varchar(80) not null)");
        jdbc.update("delete from rollback_note");
        service = context.getBean(RollbackPolicyService.class);
    }

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

    @Test
    void framework_default_is_runtime_and_error_rollback_checked_commit() {
        var rule = new DefaultTransactionAttribute();

        assertFalse(rule.rollbackOn(new RollbackPolicyService.ReportExportFailure()));
        assertTrue(rule.rollbackOn(new RollbackPolicyService.NotificationFailure()));
        assertTrue(rule.rollbackOn(new AssertionError("broken invariant")));
    }

    @Test
    void escaping_checked_exception_commits_by_default() {
        assertThrows(
                RollbackPolicyService.ReportExportFailure.class,
                () -> service.defaultChecked(11L)
        );

        assertEquals(1, rows());
    }

    @Test
    void escaping_runtime_exception_rolls_back_by_default() {
        assertThrows(
                RollbackPolicyService.NotificationFailure.class,
                () -> service.defaultRuntime(12L)
        );

        assertEquals(0, rows());
    }

    @Test
    void escaping_error_rolls_back_through_the_transaction_proxy() {
        assertTrue(AopUtils.isAopProxy(service));
        assertThrows(
                AssertionError.class,
                () -> service.defaultError(16L)
        );

        assertEquals(0, rows());
    }

    @Test
    void rollback_for_rolls_back_the_named_checked_exception() {
        assertThrows(
                RollbackPolicyService.ReportExportFailure.class,
                () -> service.rollbackChecked(13L)
        );

        assertEquals(0, rows());
    }

    @Test
    void no_rollback_for_commits_the_named_runtime_exception() {
        assertThrows(
                RollbackPolicyService.NotificationFailure.class,
                () -> service.commitRuntime(14L)
        );

        assertEquals(1, rows());
    }

    @Test
    void specific_no_rollback_rule_beats_the_matching_broad_rollback_rule() {
        assertThrows(
                RollbackPolicyService.NotificationFailure.class,
                () -> service.specificNoRollbackWins(17L)
        );

        assertEquals(1, rows());
    }

    @Test
    void caught_exception_becomes_normal_return_to_the_interceptor() {
        assertFalse(service.catchRuntimeAndReturn(15L));

        assertEquals(1, rows());
    }

    private int rows() {
        return jdbc.queryForObject(
                "select count(*) from rollback_note",
                Integer.class
        );
    }

    @Configuration(proxyBeanMethods = false)
    @EnableTransactionManagement(proxyTargetClass = true)
    static class RollbackConfig {
        @Bean
        DataSource dataSource() {
            var source = new JdbcDataSource();
            source.setURL("jdbc:h2:mem:b92_proxy_rollback;DB_CLOSE_DELAY=-1");
            source.setUser("sa");
            source.setPassword("");
            return source;
        }

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

        @Bean
        RollbackPolicyService rollbackPolicyService(DataSource dataSource) {
            return new RollbackPolicyService(dataSource);
        }
    }
}