Add an async enabled transaction synchronization (#1864)

Fixes #1752

Author: fredericDelaporte

src/NHibernate.Test/Async/NHSpecificTest/NH1082/Fixture.cs

@@ -9,9 +9,7 @@
 
 
 using System;
-using NHibernate.Cfg;
 using NUnit.Framework;
-using Environment = NHibernate.Cfg.Environment;
 
 namespace NHibernate.Test.NHSpecificTest.NH1082
 {
@@ -40,8 +38,31 @@ public async Task ExceptionsInBeforeTransactionCompletionAbortTransactionAsync()
 			}
 		}
 
-
 		[Test]
+		public async Task ExceptionsInTransactionSynchronizationBeforeTransactionCompletionAbortTransactionAsync()
+		{
+			var c = new C { ID = 1, Value = "value" };
+
+			var synchronization = new TransactionSynchronizationThatThrowsExceptionAtBeforeTransactionCompletion();
+			using (ISession s = Sfi.OpenSession())
+			using (ITransaction t = s.BeginTransaction())
+			{
+				t.RegisterSynchronization(synchronization);
+
+				await (s.SaveAsync(c));
+
+				Assert.ThrowsAsync<BadException>(() => t.CommitAsync());
+			}
+
+			using (ISession s = Sfi.OpenSession())
+			{
+				var objectInDb = await (s.GetAsync<C>(1));
+				Assert.IsNull(objectInDb);
+			}
+		}
+
+		// Since v5.2
+		[Test, Obsolete]
 		public async Task ExceptionsInSynchronizationBeforeTransactionCompletionAbortTransactionAsync()
 		{
 			var c = new C { ID = 1, Value = "value" };

src/NHibernate.Test/Async/NHSpecificTest/NH1082/TransactionSynchronizationThatThrowsExceptionAtBeforeTransactionCompletion.cs

@@ -0,0 +1,29 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using NHibernate.Transaction;
+
+namespace NHibernate.Test.NHSpecificTest.NH1082
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	public partial class TransactionSynchronizationThatThrowsExceptionAtBeforeTransactionCompletion : ITransactionCompletionSynchronization
+	{
+		public Task ExecuteBeforeTransactionCompletionAsync(CancellationToken cancellationToken)
+		{
+			throw new BadException();
+		}
+
+		public Task ExecuteAfterTransactionCompletionAsync(bool success, CancellationToken cancellationToken)
+		{
+			return Task.CompletedTask;
+		}
+	}
+}

src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs

@@ -9,8 +9,9 @@
 
 
 using System;
-using System.Collections;
+using System.Data;
 using System.Data.Common;
+using NHibernate.Transaction;
 using NUnit.Framework;
 
 namespace NHibernate.Test.TransactionTest
@@ -20,22 +21,23 @@ namespace NHibernate.Test.TransactionTest
 	[TestFixture]
 	public class TransactionNotificationFixtureAsync : TestCase
 	{
-		protected override string[] Mappings
-		{
-			get { return Array.Empty<string>(); }
-		}
+		protected override string[] Mappings => Array.Empty<string>();
 
 		[Test]
 		public async Task CommitAsync()
 		{
 			var interceptor = new RecordingInterceptor();
 			using (var session = Sfi.WithOptions().Interceptor(interceptor).OpenSession())
+			using (var tx = session.BeginTransaction())
 			{
-				ITransaction tx = session.BeginTransaction();
+				var synchronisation = new Synchronization();
+				tx.RegisterSynchronization(synchronisation);
 				await (tx.CommitAsync());
-				Assert.That(interceptor.afterTransactionBeginCalled, Is.EqualTo(1));
-				Assert.That(interceptor.beforeTransactionCompletionCalled, Is.EqualTo(1));
-				Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1));
+				Assert.That(interceptor.afterTransactionBeginCalled, Is.EqualTo(1), "interceptor begin");
+				Assert.That(interceptor.beforeTransactionCompletionCalled, Is.EqualTo(1), "interceptor before");
+				Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1), "interceptor after");
+				Assert.That(synchronisation.BeforeExecutions, Is.EqualTo(1), "sync before");
+				Assert.That(synchronisation.AfterExecutions, Is.EqualTo(1), "sync after");
 			}
 		}
 
@@ -44,26 +46,31 @@ public async Task RollbackAsync()
 		{
 			var interceptor = new RecordingInterceptor();
 			using (var session = Sfi.WithOptions().Interceptor(interceptor).OpenSession())
+			using (var tx = session.BeginTransaction())
 			{
-				ITransaction tx = session.BeginTransaction();
+				var synchronisation = new Synchronization();
+				tx.RegisterSynchronization(synchronisation);
 				await (tx.RollbackAsync());
-				Assert.That(interceptor.afterTransactionBeginCalled, Is.EqualTo(1));
-				Assert.That(interceptor.beforeTransactionCompletionCalled, Is.EqualTo(0));
-				Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1));
+				Assert.That(interceptor.afterTransactionBeginCalled, Is.EqualTo(1), "interceptor begin");
+				Assert.That(interceptor.beforeTransactionCompletionCalled, Is.EqualTo(0), "interceptor before");
+				Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1), "interceptor after");
+				Assert.That(synchronisation.BeforeExecutions, Is.EqualTo(0), "sync before");
+				Assert.That(synchronisation.AfterExecutions, Is.EqualTo(1), "sync after");
 			}
 		}
 
-
 		[Theory]
 		[Description("NH2128")]
 		public async Task ShouldNotifyAfterTransactionAsync(bool usePrematureClose)
 		{
 			var interceptor = new RecordingInterceptor();
+			var synchronisation = new Synchronization();
 			ISession s;
 
 			using (s = OpenSession(interceptor))
-			using (s.BeginTransaction())
+			using (var t = s.BeginTransaction())
 			{
+				t.RegisterSynchronization(synchronisation);
 				await (s.CreateCriteria<object>().ListAsync());
 
 				// Call session close while still inside transaction?
@@ -72,22 +79,24 @@ public async Task ShouldNotifyAfterTransactionAsync(bool usePrematureClose)
 			}
 
 			Assert.That(s.IsOpen, Is.False);
-			Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1));
+			Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1), "interceptor");
+			Assert.That(synchronisation.AfterExecutions, Is.EqualTo(1), "sync");
 		}
 
-
 		[Description("NH2128")]
 		[Theory]
 		public async Task ShouldNotifyAfterTransactionWithOwnConnectionAsync(bool usePrematureClose)
 		{
 			var interceptor = new RecordingInterceptor();
+			var synchronisation = new Synchronization();
 			ISession s;
 
 			using (var ownConnection = await (Sfi.ConnectionProvider.GetConnectionAsync(CancellationToken.None)))
 			{
 				using (s = Sfi.WithOptions().Connection(ownConnection).Interceptor(interceptor).OpenSession())
-				using (s.BeginTransaction())
+				using (var t = s.BeginTransaction())
 				{
+					t.RegisterSynchronization(synchronisation);
 					await (s.CreateCriteria<object>().ListAsync());
 
 					// Call session close while still inside transaction?
@@ -97,7 +106,56 @@ public async Task ShouldNotifyAfterTransactionWithOwnConnectionAsync(bool usePre
 			}
 
 			Assert.That(s.IsOpen, Is.False);
-			Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1));
+			Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(1), "interceptor");
+			Assert.That(synchronisation.AfterExecutions, Is.EqualTo(1), "sync");
+		}
+	}
+
+	#region Synchronization classes
+
+	public partial class CustomTransaction : ITransaction
+	{
+
+		public Task CommitAsync(CancellationToken cancellationToken = default(CancellationToken))
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task RollbackAsync(CancellationToken cancellationToken = default(CancellationToken))
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	public partial class Synchronization : ITransactionCompletionSynchronization
+	{
+
+		public Task ExecuteBeforeTransactionCompletionAsync(CancellationToken cancellationToken)
+		{
+			try
+			{
+				BeforeExecutions += 1;
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
+		}
+
+		public Task ExecuteAfterTransactionCompletionAsync(bool success, CancellationToken cancellationToken)
+		{
+			try
+			{
+				AfterExecutions += 1;
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 	}
+
+	#endregion
 }

src/NHibernate.Test/NHSpecificTest/NH1082/Fixture.cs

@@ -1,7 +1,5 @@
 using System;
-using NHibernate.Cfg;
 using NUnit.Framework;
-using Environment = NHibernate.Cfg.Environment;
 
 namespace NHibernate.Test.NHSpecificTest.NH1082
 {
@@ -29,8 +27,31 @@ public void ExceptionsInBeforeTransactionCompletionAbortTransaction()
 			}
 		}
 
-
 		[Test]
+		public void ExceptionsInTransactionSynchronizationBeforeTransactionCompletionAbortTransaction()
+		{
+			var c = new C { ID = 1, Value = "value" };
+
+			var synchronization = new TransactionSynchronizationThatThrowsExceptionAtBeforeTransactionCompletion();
+			using (ISession s = Sfi.OpenSession())
+			using (ITransaction t = s.BeginTransaction())
+			{
+				t.RegisterSynchronization(synchronization);
+
+				s.Save(c);
+
+				Assert.Throws<BadException>(t.Commit);
+			}
+
+			using (ISession s = Sfi.OpenSession())
+			{
+				var objectInDb = s.Get<C>(1);
+				Assert.IsNull(objectInDb);
+			}
+		}
+
+		// Since v5.2
+		[Test, Obsolete]
 		public void ExceptionsInSynchronizationBeforeTransactionCompletionAbortTransaction()
 		{
 			var c = new C { ID = 1, Value = "value" };

src/NHibernate.Test/NHSpecificTest/NH1082/SynchronizationThatThrowsExceptionAtBeforeTransactionCompletion.cs

@@ -1,7 +1,10 @@
+using System;
 using NHibernate.Transaction;
 
 namespace NHibernate.Test.NHSpecificTest.NH1082
 {
+	// Since v5.2
+	[Obsolete]
 	public class SynchronizationThatThrowsExceptionAtBeforeTransactionCompletion : ISynchronization
 	{
 		public void BeforeCompletion()
@@ -13,4 +16,4 @@ public void AfterCompletion(bool success)
 		{
 		}
 	}
-}
+}

src/NHibernate.Test/NHSpecificTest/NH1082/TransactionSynchronizationThatThrowsExceptionAtBeforeTransactionCompletion.cs

@@ -0,0 +1,16 @@
+using NHibernate.Transaction;
+
+namespace NHibernate.Test.NHSpecificTest.NH1082
+{
+	public partial class TransactionSynchronizationThatThrowsExceptionAtBeforeTransactionCompletion : ITransactionCompletionSynchronization
+	{
+		public void ExecuteBeforeTransactionCompletion()
+		{
+			throw new BadException();
+		}
+
+		public void ExecuteAfterTransactionCompletion(bool success)
+		{
+		}
+	}
+}