트랜잭션 전파속성(Transaction Propagation)과 롤백제어, 시나리오 테스트

개요

♣️ Poker 프로젝트 후 회고중..

환경

도메인

시나리오

시나리오 테스트

 @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processOrder(Long orderId) {

        Order order = orderRepository.findById(orderId).orElseThrow();

        // 재고 차감
        productService.decreaseOrderItemsStock(order.getOrderItems());
        log.info("decrease stock success");

        // 결제 진행
        paymentService.pay(order);
        log.info("pay success");

        // 포인트 추가
        try {
            pointService.increasePoint(order.getMember(), 100);
            log.info("increase point success");
        } catch (RuntimeException e) {
            log.error("error : {}", e.getMessage());
        }

    }

1. 재고차감
1. OrderItem의 수량만큼 Product의 재고를 차감한다.

2. 결제 진행
1. Member의 Money를 감소한다.

3. 포인트 추가
1. Member의 Point를 100만큼 증가시킨다.

시나리오 1

포인트 적립에서 예외가 발생했을 때 포인트 적립은 롤백되고 주문로직은 커밋되어야 한다.

테스트 코드

 //테스트 로직
		@Test
    @DisplayName("포인트 적립이 실패했을 때 전체 주문 로직은 커밋되어야 한다.")
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void point_fail_does_not_rollback_payment_and_stock() {

        log.info("handle test");
        // given
        doThrow(new RuntimeException("포인트 적립 실패"))
                .when(pointService).increasePoint(any(), anyInt());

        // when
        Assertions.assertDoesNotThrow(() -> orderService.processOrder(order.getId()));


        // then
        // 1. 재고 차감 확인
        List<Product> products = order.getOrderItems().stream()
                .map(item -> productRepository.findById(item.getProduct().getId()).orElseThrow())
                .toList();

        int[] originalStocks = order.getOrderItems().stream()
                .mapToInt(item -> item.getProduct().getStock())
                .toArray();

        Assertions.assertAll("재고 차감 확인",
                () -> {
                    for (int i = 0; i < products.size(); i++) {
                        int expectedStock = originalStocks[i] - order.getOrderItems().get(i).getQuantity();
                        int actualStock = productRepository.findById(products.get(i).getId()).orElseThrow().getStock();

                        Assertions.assertEquals(expectedStock, actualStock,
                                "Product " + products.get(i).getId() + " stock mismatch");
                    }
                }
        );

        // 2. Money 차감 확인
        List<OrderItem> orderItems = order.getOrderItems();
        long expectMemberMoney = order.getMember().getMoney();
        for (OrderItem orderItem : orderItems) {
            expectMemberMoney -= (long) orderItem.getProduct().getPrice() * orderItem.getQuantity();
        }

        Member member = memberRepository.findById(order.getMember().getId()).orElseThrow();
        Assertions.assertEquals(expectMemberMoney, member.getMoney());
    }

PointService

//PointService

 @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void increasePoint(Member member, int point) {
        member.increasePoint(point);
    }

테스트 설명

• 재고 차감 커밋 검증

• Money 커밋 검증

• Point 롤백 검증

테스트 결과

트랜잭션 Debug 로그

1. 포인트 적립 트랜잭션 롤백

1. ProcessOrder 트랜잭션 커밋

시나리오 2

결제 실패 시 주문도 롤백되어야 한다.

테스트 코드

 @Test
    @DisplayName("결제 실패 시 주문도 롤백되어야 한다 (분리된 트랜잭션 검증)")
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void should_rollback_order_when_payment_fails() {
        // given
        order.getPayment().setPaymentStatus(PaymentStatus.COMPLETED);
        doThrow(new AlreadyProcessOrderException())
                .when(paymentService).pay(any());

        // when
        Assertions.assertThrows(AlreadyProcessOrderException.class, () -> {
            orderService.processOrder(order.getId());
        });

        // then: 서비스 트랜잭션이 끝나고 롤백되었는지 검증
        // product 재고 롤백 검증
        int initialStock = order.getOrderItems().get(0).getProduct().getStock();
        Product product = productRepository.findById(order.getOrderItems().get(0).getProduct().getId())
                .orElseThrow();
        Assertions.assertEquals(initialStock, product.getStock(), "재고가 롤백되지 않았습니다");

    }

PaymentService

    @Transactional(propagation = Propagation.REQUIRED)
    public void pay(Order order) {
        if (!order.getPayment().getPaymentStatus().equals(PaymentStatus.PENDING)) {
            throw new AlreadyProcessOrderException();
        }

        Member member = memberRepository.findById(order.getMember().getId()).orElseThrow();
        Payment payment = paymentRepository.findById(order.getPayment().getId()).orElseThrow();

        long totalRequiredMoney = 0L;
        for (OrderItem orderItem : order.getOrderItems()) {
            totalRequiredMoney += (long) orderItem.getProduct().getPrice() * orderItem.getQuantity();
        }

        member.decreaseMoney(totalRequiredMoney);
        payment.setPaymentStatus(PaymentStatus.COMPLETED);
    }

테스트 설명

테스트 결과

트랜잭션 Debug 로그

1. Pay 트랜잭션 롤백

1. ProcessOrder 트랜잭션 롤백

시나리오 3

Checked Exception은 기본적으로 롤백되지 않는다.

테스트 코드

1. CheckedException 발생 시 스프링의 기본 전략(커밋)으로 트랜잭션을 처리

2. rollbackFor 옵션을 지정해 롤백으로 트랜잭션을 처리

 @Test
    @DisplayName("Checked Exception 이 발생했을 때 커밋되어야 한다.")
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void should_commit_checked_exception() {
        // given

        // when
        Assertions.assertThrows(MessagingException.class, () -> {
            orderService.processOrderV2(order.getId());
        });

        // then
        // product 재고 롤백 검증
        List<Product> products = order.getOrderItems().stream()
                .map(item -> productRepository.findById(item.getProduct().getId()).orElseThrow())
                .toList();

        int[] originalStocks = order.getOrderItems().stream()
                .mapToInt(item -> item.getProduct().getStock())
                .toArray();

        Assertions.assertAll("재고 차감 확인",
                () -> {
                    for (int i = 0; i < products.size(); i++) {
                        int expectedStock = originalStocks[i] - order.getOrderItems().get(i).getQuantity();
                        int actualStock = productRepository.findById(products.get(i).getId()).orElseThrow().getStock();

                        Assertions.assertEquals(expectedStock, actualStock,
                                "Product " + products.get(i).getId() + " stock mismatch");
                    }
                }
        );
    }

    @Test
    @DisplayName("이메일 전송 오류 시 롤백이 되어야 한다 (rollbackFor 테스트)")
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void should_rollback_checked_exception() throws MessagingException {
        // given
        doThrow(new MessagingException("이메일 전송 오류")).when(emailService).sendEmail(anyString());

        // when
        Assertions.assertThrows(MessagingException.class, () -> {
            orderService.processOrderV3(order.getId());
        });

        // then
        // product 재고 롤백 검증
        int initialStock = order.getOrderItems().getFirst().getProduct().getStock();
        Product product = productRepository.findById(order.getOrderItems().getFirst().getProduct().getId()).orElseThrow();
        Assertions.assertEquals(initialStock, product.getStock(), "재고가 롤백되지 않았습니다");
    }

OrderService

// V2
@Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processOrderV2(Long orderId) throws MessagingException {}
    
// V3
@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = MessagingException.class)
    public void processOrderV3(Long orderId) throws MessagingException {}

테스트 설명

1. CheckedException 발생 시 스프링의 기본 전략(커밋)으로 트랜잭션을 처리

2. rollbackFor 옵션을 지정해 롤백으로 트랜잭션을 처리

1번 테스트 결과

1번 테스트 트랜잭션 Debug 로그

2번 테스트 결과

2번 테스트 트랜잭션 Debug 로그

시나리오 4

포인트 적립에서 예외가 발생하고 부모 트랜잭션에서 try-catch로 예외를 처리했을 때도 오류가 발생한다. (REQUIRED → REQUIRED)

테스트 코드

@Test
    @DisplayName("부모 트랜잭션에서 try catch로 자식 트랜잭션에서 발생한 예외를 잡았어도 롤백이 되어야 한다.")
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void shouldRollbackParent_whenChildSetsRollbackOnly_evenIfExceptionCaught() {
        // given

        // when
        Assertions.assertThrows(RuntimeException.class, () -> {
            orderService.processOrderV4(order.getId());
        });

        // then
        // product 재고 롤백 검증
        int initialStock = order.getOrderItems().getFirst().getProduct().getStock();
        Product product = productRepository.findById(order.getOrderItems().getFirst().getProduct().getId()).orElseThrow();
        Assertions.assertEquals(initialStock, product.getStock(), "재고가 롤백되지 않았습니다");
    }

PointService

 @Transactional(propagation = Propagation.REQUIRED)
    public void increasePointV2(Member member, int point) {
        member.increasePoint(point);
        throw new RuntimeException();
    }

테스트 설명

테스트 결과

트랜잭션 Debug 로그

1. increasePointV2 트랜잭션 롤백

1. ProcessOrder 트랜잭션 롤백

마무리

Reference