Transaction async commit & Rollback (#103)

Burgyn · web-flow · commit c913c5534e5c · 2022-11-02T08:37:01.000+01:00
* Transaction async commit &amp; Rollback

* Add cancelation token to ExecuteInTransaction

* Token to action
diff --git a/src/Data/ITransaction.cs b/src/Data/ITransaction.cs
@@ -1,4 +1,6 @@
 ﻿using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Kros.KORM.Data
 {
@@ -13,11 +15,21 @@ public interface ITransaction : IDisposable
         /// </summary>
         void Commit();
 
+        /// <summary>
+        /// Async commits all changes made to the database in the current transaction.
+        /// </summary>
+        Task CommitAsync(CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Discards all changes made to the database in the current transaction.
         /// </summary>
         void Rollback();
 
+        /// <summary>
+        /// Async discards all changes made to the database in the current transaction.
+        /// </summary>
+        Task RollbackAsync(CancellationToken cancellationToken = default);
+
         /// <summary>
         /// The time in seconds to wait for the <see cref="System.Data.Common.DbCommand.CommandTimeout">command</see> in this transaction to execute.
         /// If not set, default value (30 s) will be used.
diff --git a/src/Data/TransactionHelper.cs b/src/Data/TransactionHelper.cs
@@ -4,6 +4,8 @@
 using System.Data;
 using System.Data.Common;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Kros.KORM.Data
 {
@@ -37,19 +39,45 @@ public Transaction(TransactionHelper transactionHelper, ConnectionHelper connect
             }
 
             public void Commit()
+                => OnCommit(false).GetAwaiter().GetResult();
+
+            public Task CommitAsync(CancellationToken cancellationToken = default)
+                => OnCommit(true, cancellationToken);
+
+            private async Task OnCommit(bool useAsync, CancellationToken cancellationToken = default)
             {
                 _wasCommitOrRollback = true;
                 if (_transactionHelper.CanCommitTransaction)
                 {
-                    _transaction.Value.Commit();
+                    if (useAsync)
+                    {
+                        await _transaction.Value.CommitAsync(cancellationToken);
+                    }
+                    else
+                    {
+                        _transaction.Value.Commit();
+                    }
                     _transactionHelper.EndTransaction(true);
                 }
             }
 
             public void Rollback()
+                => OnRollback(false).GetAwaiter().GetResult();
+
+            public Task RollbackAsync(CancellationToken cancellationToken = default)
+                => OnRollback(true, cancellationToken);
+
+            private async Task OnRollback(bool useAsync, CancellationToken cancellationToken = default)
             {
                 _wasCommitOrRollback = true;
-                _transaction.Value.Rollback();
+                if (useAsync)
+                {
+                    _transaction.Value.Rollback();
+                }
+                else
+                {
+                    await _transaction.Value.RollbackAsync(cancellationToken);
+                }
                 _transactionHelper.EndTransaction(false);
             }
 
@@ -105,6 +133,18 @@ public void Rollback()
                 _wasCommitOrRollback = true;
             }
 
+            public Task CommitAsync(CancellationToken cancellationToken = default)
+            {
+                Commit();
+                return Task.CompletedTask;
+            }
+
+            public Task RollbackAsync(CancellationToken cancellationToken = default)
+            {
+                Rollback();
+                return Task.CompletedTask;
+            }
+
             public int CommandTimeout
             {
                 get => _timeout;
diff --git a/src/Kros.KORM.csproj b/src/Kros.KORM.csproj
@@ -1,8 +1,8 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.1;net46</TargetFrameworks>
-    <Version>5.1.1</Version>
+    <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
+    <Version>6.0.0</Version>
     <Authors>KROS a. s.</Authors>
     <Company>KROS a. s.</Company>
     <Description>KORM is fast, easy to use, micro ORM tool (Kros Object Relation Mapper).</Description>
diff --git a/src/Query/DbSet.cs b/src/Query/DbSet.cs
@@ -355,17 +355,17 @@ private async Task CommitChangesCoreAsync(
             bool ignoreValueGenerators,
             CancellationToken cancellationToken = default)
         {
-            await _provider.ExecuteInTransactionAsync(async () =>
+            await _provider.ExecuteInTransactionAsync(async (token) =>
             {
-                await CommitChangesAddedItemsAsync(_addedItems, useAsync, ignoreValueGenerators, cancellationToken);
-                await CommitChangesEditedItemsAsync(_editedItems, useAsync, ignoreValueGenerators, cancellationToken);
-                await CommitChangesUpsertedItemsAsync(_upsertedItems, useAsync, cancellationToken);
-                await CommitChangesDeletedItemsAsync(_deletedItems, useAsync, cancellationToken);
-                await CommitChangesDeletedItemsByIdAsync(_deletedItemsIds, useAsync, cancellationToken);
-                await CommitChangesDeletedByConditionsAsync(_deleteExpressions, useAsync, cancellationToken);
+                await CommitChangesAddedItemsAsync(_addedItems, useAsync, ignoreValueGenerators, token);
+                await CommitChangesEditedItemsAsync(_editedItems, useAsync, ignoreValueGenerators, token);
+                await CommitChangesUpsertedItemsAsync(_upsertedItems, useAsync, token);
+                await CommitChangesDeletedItemsAsync(_deletedItems, useAsync, token);
+                await CommitChangesDeletedItemsByIdAsync(_deletedItemsIds, useAsync, token);
+                await CommitChangesDeletedByConditionsAsync(_deleteExpressions, useAsync, token);
 
                 Clear();
-            });
+            }, cancellationToken);
         }
 
         /// <summary>
diff --git a/src/Query/Providers/IQueryProvider.cs b/src/Query/Providers/IQueryProvider.cs
@@ -68,10 +68,11 @@ public interface IQueryProvider : System.Linq.IQueryProvider, IDisposable
         /// Asynchronously executes action in transaction.
         /// </summary>
         /// <param name="action">Action which will be executed.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>
         /// A task that represents the asynchronous operation.
         /// </returns>
-        Task ExecuteInTransactionAsync(Func<Task> action);
+        Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Executes the command.
diff --git a/src/Query/Providers/QueryProvider.cs b/src/Query/Providers/QueryProvider.cs
@@ -278,19 +278,19 @@ public async Task<object> ExecuteScalarCommandAsync(DbCommand command, Cancellat
         }
 
         /// <inheritdoc/>
-        public async Task ExecuteInTransactionAsync(Func<Task> action)
+        public async Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken = default)
         {
             using (OpenConnection())
             using (var transaction = _transactionHelper.Value.BeginTransaction())
             {
                 try
                 {
-                    await action();
-                    transaction.Commit();
+                    await action(cancellationToken);
+                    await transaction.CommitAsync(cancellationToken);
                 }
                 catch
                 {
-                    transaction.Rollback();
+                    await transaction.RollbackAsync(cancellationToken);
                     throw;
                 }
             }
diff --git a/tests/Kros.KORM.UnitTests/Integration/TransactionTests.cs b/tests/Kros.KORM.UnitTests/Integration/TransactionTests.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Kros.KORM.UnitTests.Integration
@@ -195,6 +196,40 @@ private void ExplicitTransactionCommitDataAfterOtherTransactionEndWithRollback(T
             }
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task ExplicitTransactionShould_CommitDataAfterOtherTransactionEndWithRollbackAsync(bool openConnection)
+        {
+            await DoTestWithConnectionAsync(openConnection, ExplicitTransactionCommitDataAfterOtherTransactionEndWithRollbackAsync, CreateDatabase);
+        }
+
+        private async Task ExplicitTransactionCommitDataAfterOtherTransactionEndWithRollbackAsync(TestDatabase korm)
+        {
+            using (var transaction = korm.BeginTransaction())
+            {
+                var dbSet = korm.Query<Invoice>().AsDbSet();
+
+                dbSet.Add(CreateTestData());
+                dbSet.CommitChanges();
+
+                await transaction.RollbackAsync();
+
+                DatabaseShouldBeEmpty(korm);
+            }
+            using (var transaction = korm.BeginTransaction())
+            {
+                var dbSet = korm.Query<Invoice>().AsDbSet();
+
+                dbSet.Add(CreateTestData());
+                dbSet.CommitChanges();
+
+                await transaction.CommitAsync();
+
+                DatabaseShouldContainInvoices(korm.ConnectionString, CreateTestData());
+            }
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
@@ -369,6 +404,30 @@ private void ExplicitTransactionCommit(TestDatabase database)
             }
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task ExplicitTransactionShould_KeepMasterConnectionStateWhenCommitWasCalledAsync(bool openConnection)
+        {
+            await DoTestWithConnectionAsync(openConnection, ExplicitTransactionCommitAsync, CreateDatabase);
+        }
+
+        private async Task ExplicitTransactionCommitAsync(TestDatabase database)
+        {
+            using (var korm = new Database(database.ConnectionString))
+            using (var transaction = korm.BeginTransaction())
+            {
+                var dbSet = korm.Query<Invoice>().AsDbSet();
+
+                dbSet.Add(CreateTestData());
+                dbSet.CommitChanges();
+
+                await transaction.CommitAsync();
+
+                DatabaseShouldContainInvoices(database.ConnectionString, CreateTestData());
+            }
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
@@ -509,17 +568,34 @@ public void ExplicitTransactionShould_NotThrowCommandTimeoutExceptionWhenIsSetSu
 
         #region Helpers
 
-        private void DoTestWithConnection(
+        private static void DoTestWithConnection(
             bool openConnection,
             Action<TestDatabase> testAction,
             Func<TestDatabase> createDatabaseAction)
         {
-            using (var database = createDatabaseAction())
+            using TestDatabase database = createDatabaseAction();
+            if (openConnection)
+            {
+                database.Connection.Open();
+            }
+
+            testAction(database);
+            database.Connection.State.Should().Be(openConnection ? ConnectionState.Open : ConnectionState.Closed);
+        }
+
+        private static async Task DoTestWithConnectionAsync(
+            bool openConnection,
+            Func<TestDatabase, Task> testAction,
+            Func<TestDatabase> createDatabaseAction)
+        {
+            using TestDatabase database = createDatabaseAction();
+            if (openConnection)
             {
-                if (openConnection) database.Connection.Open();
-                testAction(database);
-                database.Connection.State.Should().Be(openConnection ? ConnectionState.Open : ConnectionState.Closed);
+                database.Connection.Open();
             }
+
+            await testAction(database);
+            database.Connection.State.Should().Be(openConnection ? ConnectionState.Open : ConnectionState.Closed);
         }
 
         private void DatabaseShouldContainInvoices(Database korm, IEnumerable<Invoice> expected)
diff --git a/tests/Kros.KORM.UnitTests/Query/DbSetShould.cs b/tests/Kros.KORM.UnitTests/Query/DbSetShould.cs
@@ -324,7 +324,7 @@ public class Person
 
         private class FakeProvider : IQueryProvider
         {
-            async Task IQueryProvider.ExecuteInTransactionAsync(Func<Task> action) => await action();
+            async Task IQueryProvider.ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken) => await action(cancellationToken);
             int IQueryProvider.ExecuteNonQueryCommand(IDbCommand command) => command.ExecuteNonQuery();
             bool IQueryProvider.SupportsIdentity() => false;
             bool IQueryProvider.SupportsPrepareCommand() => true;

Original file line number	Diff line number	Diff line change
`@@ -278,19 +278,19 @@ public async Task<object> ExecuteScalarCommandAsync(DbCommand command, Cancellat`
`278`	`278`	`}`
`279`	`279`
`280`	`280`	`/// <inheritdoc/>`
`281`		`- public async Task ExecuteInTransactionAsync(Func<Task> action)`
	`281`	`+ public async Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken = default)`
`282`	`282`	`{`
`283`	`283`	`using (OpenConnection())`
`284`	`284`	`using (var transaction = _transactionHelper.Value.BeginTransaction())`
`285`	`285`	`{`
`286`	`286`	`try`
`287`	`287`	`{`
`288`		`- await action();`
`289`		`- transaction.Commit();`
	`288`	`+ await action(cancellationToken);`
	`289`	`+ await transaction.CommitAsync(cancellationToken);`
`290`	`290`	`}`
`291`	`291`	`catch`
`292`	`292`	`{`
`293`		`- transaction.Rollback();`
	`293`	`+ await transaction.RollbackAsync(cancellationToken);`
`294`	`294`	`throw;`
`295`	`295`	`}`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -324,7 +324,7 @@ public class Person`
`324`	`324`
`325`	`325`	`private class FakeProvider : IQueryProvider`
`326`	`326`	`{`
`327`		`- async Task IQueryProvider.ExecuteInTransactionAsync(Func<Task> action) => await action();`
	`327`	`+ async Task IQueryProvider.ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken) => await action(cancellationToken);`
`328`	`328`	`int IQueryProvider.ExecuteNonQueryCommand(IDbCommand command) => command.ExecuteNonQuery();`
`329`	`329`	`bool IQueryProvider.SupportsIdentity() => false;`
`330`	`330`	`bool IQueryProvider.SupportsPrepareCommand() => true;`