Fix EXEC without MULTI when using coroutines over async

src/main/kotlin/io/lettuce/core/api/async/RedisAsyncCommandsExtensions.kt

@@ -26,12 +26,11 @@ import kotlinx.coroutines.future.await
  * @since 6.0
  */
 @ExperimentalLettuceCoroutinesApi
-suspend inline fun <K, V> RedisAsyncCommands<K, V>.multi(action: RedisAsyncCommands<K, V>.() -> Unit): TransactionResult {
+suspend inline fun <K, V> RedisAsyncCommands<K, V>.multi(action: RedisAsyncCommands<K, V>.() -> Unit): TransactionResult = try {
     multi().await()
-    runCatching {
-        action.invoke(this)
-    }.onFailure {
-        discard()
-    }
-    return exec().await()
+    action.invoke(this)
+    exec().await()
+} catch (thr: Throwable) {
+    discard().await()
+    throw thr
 }

src/main/kotlin/io/lettuce/core/api/coroutines/RedisCoroutinesCommandsExtensions.kt

@@ -25,12 +25,11 @@ import io.lettuce.core.TransactionResult
  * @since 6.0
  */
 @ExperimentalLettuceCoroutinesApi
-suspend inline fun <K : Any, V : Any> RedisCoroutinesCommands<K, V>.multi(action: RedisCoroutinesCommands<K, V>.() -> Unit): TransactionResult? {
+suspend inline fun <K : Any, V : Any> RedisCoroutinesCommands<K, V>.multi(action: RedisCoroutinesCommands<K, V>.() -> Unit): TransactionResult? = try {
     multi()
-    runCatching {
-        action.invoke(this)
-    }.onFailure {
-        discard()
-    }
-    return exec()
+    action.invoke(this)
+    exec()
+} catch (thr: Throwable) {
+    discard()
+    throw thr
 }

src/main/kotlin/io/lettuce/core/api/sync/RedisSyncCommandsExtensions.kt

@@ -25,12 +25,11 @@ import io.lettuce.core.TransactionResult
  * @since 6.0
  */
 @ExperimentalLettuceCoroutinesApi
-inline fun <K, V> RedisCommands<K, V>.multi(action: RedisCommands<K, V>.() -> Unit): TransactionResult {
+inline fun <K, V> RedisCommands<K, V>.multi(action: RedisCommands<K, V>.() -> Unit): TransactionResult = try {
     multi()
-    runCatching {
-        action.invoke(this)
-    }.onFailure {
-        discard()
-    }
-    return exec()
+    action.invoke(this)
+    exec()
+} catch (thr: Throwable) {
+    discard()
+    throw thr
 }

src/test/kotlin/io/lettuce/core/TransactionExtensionsIntegrationTests.kt

@@ -19,6 +19,7 @@ import io.lettuce.core.api.StatefulRedisConnection
 import io.lettuce.core.api.async.multi
 import io.lettuce.core.api.sync.multi
 import io.lettuce.test.LettuceExtension
+import kotlinx.coroutines.future.await
 import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
@@ -62,4 +63,22 @@ class TransactionExtensionsIntegrationTests : TestSupport() {
         }
     }
 
+    @Test
+    @Inject
+    internal fun shouldDiscardMultiClosureOverAsync(connection: StatefulRedisConnection<String, String>) {
+
+        runBlocking {
+            val transactionResult = runCatching {
+                connection.async().multi {
+                    set("key", "value")
+                    throw RedisCommandExecutionException("oops")
+                }
+            }
+
+            assertThat(transactionResult.isFailure).isTrue()
+            assertThat(transactionResult.exceptionOrNull()).isInstanceOf(RedisCommandExecutionException::class.java)
+            assertThat(connection.async().get("key").await()).isNull()
+        }
+    }
+
 }