NH-4011 - Moving DtcFailures to system transaction tests, and completing non distributed tests

Author: fredericDelaporte

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

@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System.Data;
 using NUnit.Framework;
 
 namespace NHibernate.Test.NHSpecificTest.NH1632
@@ -38,6 +39,9 @@ protected override void Configure(Configuration configuration)
 		[Test]
 		public async Task When_using_DTC_HiLo_knows_to_create_isolated_DTC_transactionAsync()
 		{
+			if (!Dialect.SupportsConcurrentWritingConnections)
+				Assert.Ignore(Dialect.GetType().Name + " does not support concurrent writing connections, can not isolate work.");
+
 			object scalar1, scalar2;
 
 			using (var session = Sfi.OpenSession())
@@ -47,18 +51,19 @@ public async Task When_using_DTC_HiLo_knows_to_create_isolated_DTC_transactionAs
 				scalar1 = await (command.ExecuteScalarAsync());
 			}
 
-			using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
+			using (new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
 			{
 				var generator = Sfi.GetIdentifierGenerator(typeof(Person).FullName);
 				Assert.That(generator, Is.InstanceOf<TableHiLoGenerator>());
 
 				using (var session = OpenSession())
 				{
-					var id = await (generator.GenerateAsync((ISessionImplementor)session, new Person(), CancellationToken.None));
+					// Force connection acquisition for having it enlisted.
+					Assert.That(session.Connection.State, Is.EqualTo(ConnectionState.Open));
+					await (generator.GenerateAsync((ISessionImplementor)session, new Person(), CancellationToken.None));
 				}
 
 				// intentionally dispose without committing
-				tx.Dispose();
 			}
 
 			using (var session = Sfi.OpenSession())

src/NHibernate.Test/Async/NHSpecificTest/DtcFailures/DtcFailuresFixture.cs renamed to src/NHibernate.Test/Async/SystemTransactions/DistributedSystemTransactionFixture.cs

@@ -9,72 +9,30 @@
 
 
 using System;
-using System.Collections;
 using System.Linq;
-using System.Reflection;
 using System.Threading;
 using System.Transactions;
 using log4net;
 using log4net.Repository.Hierarchy;
-using NHibernate.Cfg;
-using NHibernate.Cfg.MappingSchema;
 using NHibernate.Linq;
-using NHibernate.Tool.hbm2ddl;
+using NHibernate.Test.TransactionTest;
 using NUnit.Framework;
 
-namespace NHibernate.Test.NHSpecificTest.DtcFailures
+namespace NHibernate.Test.SystemTransactions
 {
 	using System.Threading.Tasks;
 	[TestFixture]
-	public class DtcFailuresFixtureAsync : TestCase
+	public class DistributedSystemTransactionFixtureAsync : SystemTransactionFixtureBase
 	{
-		private static readonly ILog _log = LogManager.GetLogger(typeof(DtcFailuresFixtureAsync));
-
-		protected override IList Mappings
-			=> new[] { "NHSpecificTest.DtcFailures.Mappings.hbm.xml" };
-
-		protected override string MappingsAssembly
-			=> "NHibernate.Test";
+		private static readonly ILog _log = LogManager.GetLogger(typeof(DistributedSystemTransactionFixtureAsync));
 
 		protected override bool AppliesTo(Dialect.Dialect dialect)
-			=> dialect.SupportsDistributedTransactions;
-
-		protected override void CreateSchema()
-		{
-			// Copied from Configure method.
-			var config = new Configuration();
-			if (TestConfigurationHelper.hibernateConfigFile != null)
-				config.Configure(TestConfigurationHelper.hibernateConfigFile);
-
-			// Our override so we can set nullability on database column without NHibernate knowing about it.
-			config.BeforeBindMapping += BeforeBindMapping;
-
-			// Copied from AddMappings methods.
-			var assembly = Assembly.Load(MappingsAssembly);
-			foreach (var file in Mappings)
-				config.AddResource(MappingsAssembly + "." + file, assembly);
-
-			// Copied from CreateSchema method, but we use our own config.
-			new SchemaExport(config).Create(false, true);
-		}
+			=> dialect.SupportsDistributedTransactions && base.AppliesTo(dialect);
 
 		protected override void OnTearDown()
 		{
 			DodgeTransactionCompletionDelayIfRequired();
-
-			using (var s = OpenSession())
-			using (var t = s.BeginTransaction())
-			{
-				s.CreateQuery("delete from System.Object").ExecuteUpdate();
-				t.Commit();
-			}
-		}
-
-		private void BeforeBindMapping(object sender, BindMappingEventArgs e)
-		{
-			var prop = e.Mapping.RootClasses[0].Properties.OfType<HbmProperty>().Single(p => p.Name == "NotNullData");
-			prop.notnull = true;
-			prop.notnullSpecified = true;
+			base.OnTearDown();
 		}
 
 		[Test]
@@ -91,7 +49,7 @@ public async Task SupportsEnlistingInDistributedAsync()
 
 				using (var s = OpenSession())
 				{
-					await (s.SaveAsync(new Person { CreatedAt = DateTime.Now }));
+					await (s.SaveAsync(new Person()));
 					// Ensure the connection is acquired (thus enlisted)
 					Assert.DoesNotThrowAsync(() => s.FlushAsync(), "Failure enlisting a connection in a distributed transaction.");
 				}
@@ -105,7 +63,7 @@ public async Task SupportsPromotingToDistributedAsync()
 			{
 				using (var s = OpenSession())
 				{
-					await (s.SaveAsync(new Person { CreatedAt = DateTime.Now }));
+					await (s.SaveAsync(new Person()));
 					// Ensure the connection is acquired (thus enlisted)
 					await (s.FlushAsync());
 				}
@@ -119,7 +77,7 @@ public async Task SupportsPromotingToDistributedAsync()
 		}
 
 		[Test]
-		public async Task WillNotCrashOnDtcPrepareFailureAsync()
+		public async Task WillNotCrashOnPrepareFailureAsync()
 		{
 			var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
 			var disposeCalled = false;
@@ -163,7 +121,7 @@ public async Task CanRollbackTransactionAsync([Values(false, true)] bool explici
 				using (var s = OpenSession())
 				{
 					ForceEscalationToDistributedTx.Escalate(true); //will rollback tx
-					await (s.SaveAsync(new Person { CreatedAt = DateTime.Today }));
+					await (s.SaveAsync(new Person()));
 
 					if (explicitFlush)
 						await (s.FlushAsync());
@@ -189,7 +147,7 @@ public async Task CanRollbackTransactionAsync([Values(false, true)] bool explici
 				}
 			}
 
-			await (AssertNoPersonsAsync());
+			AssertNoPersons();
 		}
 
 		[Test]
@@ -199,14 +157,14 @@ public async Task CanRollbackTransactionFromScopeAsync([Values(false, true)] boo
 			using (var s = OpenSession())
 			{
 				ForceEscalationToDistributedTx.Escalate();
-				await (s.SaveAsync(new Person { CreatedAt = DateTime.Today }));
+				await (s.SaveAsync(new Person()));
 
 				if (explicitFlush)
 					await (s.FlushAsync());
 				// No Complete call for triggering rollback.
 			}
 
-			await (AssertNoPersonsAsync());
+			AssertNoPersons();
 		}
 
 		[Test]
@@ -219,7 +177,7 @@ public async Task RollbackOutsideNhAsync([Values(false, true)] bool explicitFlus
 				{
 					using (var s = OpenSession())
 					{
-						var person = new Person { CreatedAt = DateTime.Now };
+						var person = new Person();
 						await (s.SaveAsync(person));
 
 						if (explicitFlush)
@@ -237,7 +195,7 @@ public async Task RollbackOutsideNhAsync([Values(false, true)] bool explicitFlus
 				_log.Debug("Transaction aborted.");
 			}
 
-			await (AssertNoPersonsAsync());
+			AssertNoPersons();
 		}
 
 		[Test]
@@ -248,17 +206,16 @@ public async Task TransactionInsertWithRollBackFromScopeAsync([Values(false, tru
 			{
 				using (var s = OpenSession())
 				{
-					var person = new Person { CreatedAt = DateTime.Now };
+					var person = new Person();
 					await (s.SaveAsync(person));
 					ForceEscalationToDistributedTx.Escalate();
-					person.CreatedAt = DateTime.Now;
 
 					if (explicitFlush)
 						await (s.FlushAsync());
 				}
 				// No Complete call for triggering rollback.
 			}
-			await (AssertNoPersonsAsync());
+			AssertNoPersons();
 		}
 
 		[Test]
@@ -271,10 +228,9 @@ public async Task TransactionInsertWithRollBackTaskAsync([Values(false, true)] b
 				{
 					using (var s = OpenSession())
 					{
-						var person = new Person { CreatedAt = DateTime.Now };
+						var person = new Person();
 						await (s.SaveAsync(person));
 						ForceEscalationToDistributedTx.Escalate(true); //will rollback tx
-						person.CreatedAt = DateTime.Now;
 
 						if (explicitFlush)
 							await (s.FlushAsync());
@@ -289,7 +245,7 @@ public async Task TransactionInsertWithRollBackTaskAsync([Values(false, true)] b
 				_log.Debug("Transaction aborted.");
 			}
 
-			await (AssertNoPersonsAsync());
+			AssertNoPersons();
 		}
 
 		[Test]
@@ -396,7 +352,7 @@ public async Task CanDeleteItemInDtcAsync([Values(false, true)] bool explicitFlu
 			{
 				using (var s = OpenSession())
 				{
-					id = await (s.SaveAsync(new Person { CreatedAt = DateTime.Today }));
+					id = await (s.SaveAsync(new Person()));
 
 					ForceEscalationToDistributedTx.Escalate();
 
@@ -432,7 +388,7 @@ public async Task CanDeleteItemInDtcAsync([Values(false, true)] bool explicitFlu
 
 			DodgeTransactionCompletionDelayIfRequired();
 
-			await (AssertNoPersonsAsync());
+			AssertNoPersons();
 		}
 
 		[Test]
@@ -455,14 +411,82 @@ public async Task NH1744Async()
 			}
 		}
 
+		[Test]
+		public async Task CanUseSessionWithManyScopesAsync([Values(false, true)] bool explicitFlush)
+		{
+			// Note that this fails with ConnectionReleaseMode.OnClose and SqlServer:
+			// System.Data.SqlClient.SqlException : Microsoft Distributed Transaction Coordinator (MS DTC) has stopped this transaction.
+			using (var s = OpenSession())
+			//using (var s = Sfi.WithOptions().ConnectionReleaseMode(ConnectionReleaseMode.OnClose).OpenSession())
+			{
+				using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
+				{
+					ForceEscalationToDistributedTx.Escalate();
+					// Acquire the connection
+					var count = await (s.Query<Person>().CountAsync());
+					Assert.That(count, Is.EqualTo(0), "Unexpected initial entity count.");
+					tx.Complete();
+				}
+				// No dodge here please! Allow to check chaining usages do not fail.
+				using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
+				{
+					await (s.SaveAsync(new Person()));
+
+					ForceEscalationToDistributedTx.Escalate();
+
+					if (explicitFlush)
+						await (s.FlushAsync());
+
+					tx.Complete();
+				}
+
+				DodgeTransactionCompletionDelayIfRequired();
+
+				using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
+				{
+					ForceEscalationToDistributedTx.Escalate();
+					var count = await (s.Query<Person>().CountAsync());
+					Assert.That(count, Is.EqualTo(1), "Unexpected entity count after committed insert.");
+					tx.Complete();
+				}
+				using (new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
+				{
+					await (s.SaveAsync(new Person()));
+
+					ForceEscalationToDistributedTx.Escalate();
+
+					if (explicitFlush)
+						await (s.FlushAsync());
+
+					// No complete for rollback-ing.
+				}
+
+				DodgeTransactionCompletionDelayIfRequired();
+
+				// Do not reuse the session after a rollback, its state does not allow it.
+				// http://nhibernate.info/doc/nhibernate-reference/manipulatingdata.html#manipulatingdata-endingsession-commit
+			}
+
+			using (var s = OpenSession())
+			{
+				using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
+				{
+					ForceEscalationToDistributedTx.Escalate();
+					var count = await (s.Query<Person>().CountAsync());
+					Assert.That(count, Is.EqualTo(1), "Unexpected entity count after rollback-ed insert.");
+					tx.Complete();
+				}
+			}
+		}
+
 		[Test]
 		public async Task CanUseSessionOutsideOfScopeAfterScopeAsync([Values(false, true)] bool explicitFlush)
 		{
 			using (var s = Sfi.WithOptions().ConnectionReleaseMode(ConnectionReleaseMode.OnClose).OpenSession())
 			{
 				using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
 				{
-					await (s.SaveAsync(new Person { CreatedAt = DateTime.Today }));
+					await (s.SaveAsync(new Person()));
 
 					ForceEscalationToDistributedTx.Escalate();
 
@@ -498,7 +522,7 @@ public async Task DelayedTransactionCompletionAsync([Values(false, true)] bool e
 					{
 						using (var s = OpenSession())
 						{
-							await (s.SaveAsync(new Person { CreatedAt = DateTime.Today }));
+							await (s.SaveAsync(new Person()));
 
 							ForceEscalationToDistributedTx.Escalate();
 
@@ -511,6 +535,15 @@ public async Task DelayedTransactionCompletionAsync([Values(false, true)] bool e
 					var count = await (controlSession.Query<Person>().CountAsync());
 					if (count != i)
 					{
+						// See https://github.com/npgsql/npgsql/issues/1571#issuecomment-308651461 discussion with a Microsoft
+						// employee: MSDTC consider a transaction to be committed once it has collected all participant votes
+						// for committing from prepare phase. It then immediately notifies all participants of the outcome.
+						// This causes TransactionScope.Dispose to leave while the second phase of participants may still
+						// be executing. This means the transaction from the db view point can still be pending and not yet
+						// committed. This is by design of MSDTC and we have to cope with that. Some data provider may have
+						// a global locking mechanism causing any subsequent use to wait for the end of the commit phase,
+						// but this is not the usual case. Some other, as Npgsql < v3.2.5, may crash due to this, because
+						// they re-use the connection for the second phase.
 						Thread.Sleep(100);
 						var countSecondTry = await (controlSession.Query<Person>().CountAsync());
 						Assert.Warn($"Unexpected entity count: {count} instead of {i}. " +
@@ -522,13 +555,20 @@ public async Task DelayedTransactionCompletionAsync([Values(false, true)] bool e
 			}
 		}
 
-		private async Task AssertNoPersonsAsync(CancellationToken cancellationToken = default(CancellationToken))
+		[Test]
+		public async Task DoNotDeadlockOnAfterTransactionWaitAsync()
 		{
-			using (var s = OpenSession())
-			using (s.BeginTransaction())
+			var interceptor = new AfterTransactionWaitingInterceptor();
+			using (var s = Sfi.WithOptions().Interceptor(interceptor).OpenSession())
+			using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
 			{
-				Assert.AreEqual(0, await (s.Query<Person>().CountAsync(cancellationToken)), "Entities found in database.");
+				ForceEscalationToDistributedTx.Escalate();
+				await (s.SaveAsync(new Person()));
+
+				await (s.FlushAsync());
+				tx.Complete();
 			}
+			Assert.That(interceptor.Exception, Is.Null);
 		}
 
 		private void DodgeTransactionCompletionDelayIfRequired()