Transaction manager should catch Throwable (#2954)

micronaut-projects · May 22, 2024 · 25a7a06 · 25a7a06
1 parent 28b4804
commit 25a7a06
Show file tree

Hide file tree

Showing 4 changed files with 77 additions and 4 deletions.
diff --git a/...-tx/src/main/java/io/micronaut/transaction/async/AsyncUsingSyncTransactionOperations.java b/...-tx/src/main/java/io/micronaut/transaction/async/AsyncUsingSyncTransactionOperations.java
@@ -47,13 +47,12 @@ public <T> CompletionStage<T> withTransaction(TransactionDefinition definition,
                                                   Function<AsyncTransactionStatus<C>, CompletionStage<T>> handler) {
         CompletableFuture<T> newResult = new CompletableFuture<>();
         PropagatedContext propagatedContext = PropagatedContext.getOrEmpty();
-        try (PropagatedContext.Scope scope = propagatedContext.propagate()) { // Propagate to clean up the scope
+        try (PropagatedContext.Scope ignore = propagatedContext.propagate()) { // Propagate to clean up the scope
             TransactionStatus<C> status = synchronousTransactionManager.getTransaction(definition);
-            PropagatedContext txPropagatedContext = PropagatedContext.get();
             CompletionStage<T> result;
             try {
                 result = handler.apply(new DefaultAsyncTransactionStatus<>(status));
-            } catch (Exception e) {
+            } catch (Throwable e) {
                 CompletableFuture<T> r = new CompletableFuture<>();
                 r.completeExceptionally(e);
                 result = r;

diff --git a/data-tx/src/main/java/io/micronaut/transaction/support/AbstractTransactionOperations.java b/data-tx/src/main/java/io/micronaut/transaction/support/AbstractTransactionOperations.java
@@ -331,7 +331,7 @@ private <R> R executeTransactional(T transaction, TransactionCallback<C, R> call
         R result;
         try {
             result = callback.apply(transaction);
-        } catch (Exception e) {
+        } catch (Throwable e) {
             if (definition.rollbackOn(e)) {
                 rollbackInternal(transaction);
             } else {

diff --git a/doc-examples/jdbc-example-kotlin/src/main/kotlin/example/PersonSuspendRepositoryService.kt b/doc-examples/jdbc-example-kotlin/src/main/kotlin/example/PersonSuspendRepositoryService.kt
@@ -59,6 +59,28 @@ open class PersonSuspendRepositoryService(private val parentSuspendRepository: P
         throw RuntimeException("exception")
     }
 
+    @Transactional
+    open fun normalStoreThrowable() {
+        saveOne()
+        throw Throwable("exception")
+    }
+
+    @Transactional
+    open fun normalThrowable() {
+        throw Throwable("exception")
+    }
+
+    @Transactional
+    open suspend fun coroutinesStoreThrowable() {
+        saveOneSuspended()
+        throw Throwable("exception")
+    }
+
+    @Transactional
+    open suspend fun coroutinesThrowable() {
+        throw Throwable("exception")
+    }
+
     @Transactional
     open suspend fun coroutinesStore() {
         saveOneSuspended()

diff --git a/doc-examples/jdbc-example-kotlin/src/test/kotlin/example/TxTest.kt b/doc-examples/jdbc-example-kotlin/src/test/kotlin/example/TxTest.kt
@@ -154,4 +154,56 @@ class TxTest {
         Assertions.assertEquals(0, service.countForCustomDb())
     }
 
+    @Test
+    @Order(12)
+    fun storeThrowable() {
+        repeat(10000) { // Validate the connection is properly closed
+            assertThrows<Throwable> {
+                service.normalStoreThrowable()
+            }
+
+            Assertions.assertEquals(0, service.count())
+        }
+    }
+
+    @Test
+    @Order(13)
+    fun throwable() {
+        repeat(10000) { // Validate the connection is properly closed
+            assertThrows<Throwable> {
+                service.normalThrowable()
+            }
+
+            Assertions.assertEquals(0, service.count())
+        }
+    }
+
+    @Test
+    @Order(14)
+    fun coroutineStoreThrowable() {
+        runBlocking {
+            repeat(10000) { // Validate the connection is properly closed
+                assertThrows<Throwable> {
+                    service.coroutinesStoreThrowable()
+                }
+
+                Assertions.assertEquals(0, service.count())
+            }
+        }
+    }
+
+    @Test
+    @Order(15)
+    fun coroutineThrowable() {
+        runBlocking {
+            repeat(10000) { // Validate the connection is properly closed
+                assertThrows<Throwable> {
+                    service.coroutinesThrowable()
+                }
+
+                Assertions.assertEquals(0, service.count())
+            }
+        }
+    }
+
 }