NH-3807 - Ignore tests that don't work with distributed transactions in .NET core.

ngbrown · ngbrown · commit ef1ee6ad65c8 · 2018-01-26T04:53:57.000-07:00
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH1632/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH1632/Fixture.cs
@@ -37,6 +37,9 @@ protected override void Configure(Configuration configuration)
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task When_using_DTC_HiLo_knows_to_create_isolated_DTC_transactionAsync()
 		{
 			if (!Dialect.SupportsConcurrentWritingConnections)
@@ -76,8 +79,10 @@ public async Task When_using_DTC_HiLo_knows_to_create_isolated_DTC_transactionAs
 			Assert.AreNotEqual(scalar1, scalar2, "HiLo must run with in its own transaction");
 		}
 
-
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_level_cacheAsync()
 		{
 			using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
@@ -131,6 +136,9 @@ public async Task When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task When_committing_transaction_scope_will_commit_transactionAsync()
 		{
 			object id;
@@ -178,6 +186,9 @@ public async Task Will_not_save_when_flush_mode_is_neverAsync()
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task When_using_two_sessions_with_explicit_flushAsync()
 		{
 			if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)
@@ -218,6 +229,9 @@ public async Task When_using_two_sessions_with_explicit_flushAsync()
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task When_using_two_sessionsAsync()
 		{
 			if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2057/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2057/Fixture.cs
@@ -19,6 +19,9 @@ namespace NHibernate.Test.NHSpecificTest.NH2057
 	public class FixtureAsync : BugTestCase
 	{
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task WillCloseWhenUsingDTCAsync()
 		{
 			ISession s;
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2176/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2176/Fixture.cs
@@ -56,6 +56,9 @@ protected override void OnTearDown()
 		// Whilst this bug seems specific to Oracle I think it is valid to run the
 		// test against all database types.
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSessionAsync()
 		{
 			using (var s = OpenSession())
@@ -84,4 +87,4 @@ public async Task MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSess
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2420/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2420/Fixture.cs
@@ -61,6 +61,9 @@ private string FetchConnectionStringFromConfiguration()
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransactionAsync()
 		{
 			string connectionString = FetchConnectionStringFromConfiguration();
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH3023/DeadlockConnectionPoolIssueTest.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH3023/DeadlockConnectionPoolIssueTest.cs
@@ -75,6 +75,19 @@ protected override void OnTearDown()
 		[Theory]
 		public async Task ConnectionPoolCorruptionAfterDeadlockAsync(bool distributed, bool disposeSessionBeforeScope)
 		{
+			if (distributed)
+			{
+#if NETCOREAPP2_0
+				Assert.Ignore("This platform does not support distributed transactions.");
+#endif
+			}
+			else
+			{
+#if NETCOREAPP2_0
+				Assert.Ignore("Enlisting in Ambient transactions is not supported by System.Data.SqlClient.");
+#endif
+			}
+
 			var tryCount = 0;
 			var id = 1;
 			do
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH3583/AutoFlushFixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH3583/AutoFlushFixture.cs
@@ -61,7 +61,11 @@ public async Task ShouldAutoFlushWhenInExplicitTransactionAsync()
 				Assert.That(result.Count, Is.EqualTo(1));
 			}
 		}
+
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task ShouldAutoFlushWhenInDistributedTransactionAsync()
 		{
 			using (new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
diff --git a/src/NHibernate.Test/Async/ReadOnly/ReadOnlyCriteriaQueryTest.cs b/src/NHibernate.Test/Async/ReadOnly/ReadOnlyCriteriaQueryTest.cs
@@ -1066,6 +1066,9 @@ public async Task SubselectAsync()
 		}
 		
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public async Task DetachedCriteriaAsync()
 		{
 			DetachedCriteria dc = NHibernate.Criterion.DetachedCriteria.For<Student>()
diff --git a/src/NHibernate.Test/NHSpecificTest/NH1632/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/NH1632/Fixture.cs
@@ -25,6 +25,9 @@ protected override void Configure(Configuration configuration)
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void When_using_DTC_HiLo_knows_to_create_isolated_DTC_transaction()
 		{
 			if (!Dialect.SupportsConcurrentWritingConnections)
@@ -81,8 +84,10 @@ public void Dispose_session_inside_transaction_scope()
 			Assert.IsFalse(s.IsOpen);
 		}
 
-
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_level_cache()
 		{
 			using (var tx = new TransactionScope())
@@ -136,6 +141,9 @@ public void When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_level_
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void When_committing_transaction_scope_will_commit_transaction()
 		{
 			object id;
@@ -183,6 +191,9 @@ public void Will_not_save_when_flush_mode_is_never()
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void When_using_two_sessions_with_explicit_flush()
 		{
 			if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)
@@ -223,6 +234,9 @@ public void When_using_two_sessions_with_explicit_flush()
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void When_using_two_sessions()
 		{
 			if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)
diff --git a/src/NHibernate.Test/NHSpecificTest/NH2057/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/NH2057/Fixture.cs
@@ -8,6 +8,9 @@ namespace NHibernate.Test.NHSpecificTest.NH2057
 	public class Fixture : BugTestCase
 	{
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void WillCloseWhenUsingDTC()
 		{
 			ISession s;
diff --git a/src/NHibernate.Test/NHSpecificTest/NH2176/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/NH2176/Fixture.cs
@@ -45,6 +45,9 @@ protected override void OnTearDown()
 		// Whilst this bug seems specific to Oracle I think it is valid to run the
 		// test against all database types.
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSession()
 		{
 			using (var s = OpenSession())
@@ -73,4 +76,4 @@ public void MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSession()
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs
@@ -50,6 +50,9 @@ private string FetchConnectionStringFromConfiguration()
 		}
 
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransaction()
 		{
 			string connectionString = FetchConnectionStringFromConfiguration();
diff --git a/src/NHibernate.Test/NHSpecificTest/NH3023/DeadlockConnectionPoolIssueTest.cs b/src/NHibernate.Test/NHSpecificTest/NH3023/DeadlockConnectionPoolIssueTest.cs
@@ -64,6 +64,19 @@ protected override void OnTearDown()
 		[Theory]
 		public void ConnectionPoolCorruptionAfterDeadlock(bool distributed, bool disposeSessionBeforeScope)
 		{
+			if (distributed)
+			{
+#if NETCOREAPP2_0
+				Assert.Ignore("This platform does not support distributed transactions.");
+#endif
+			}
+			else
+			{
+#if NETCOREAPP2_0
+				Assert.Ignore("Enlisting in Ambient transactions is not supported by System.Data.SqlClient.");
+#endif
+			}
+
 			var tryCount = 0;
 			var id = 1;
 			do
diff --git a/src/NHibernate.Test/NHSpecificTest/NH3583/AutoFlushFixture.cs b/src/NHibernate.Test/NHSpecificTest/NH3583/AutoFlushFixture.cs
@@ -50,7 +50,11 @@ public void ShouldAutoFlushWhenInExplicitTransaction()
 				Assert.That(result.Count, Is.EqualTo(1));
 			}
 		}
+
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void ShouldAutoFlushWhenInDistributedTransaction()
 		{
 			using (new TransactionScope())
diff --git a/src/NHibernate.Test/ReadOnly/ReadOnlyCriteriaQueryTest.cs b/src/NHibernate.Test/ReadOnly/ReadOnlyCriteriaQueryTest.cs
@@ -1054,6 +1054,9 @@ public void Subselect()
 		}
 		
 		[Test]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void DetachedCriteria()
 		{
 			DetachedCriteria dc = NHibernate.Criterion.DetachedCriteria.For<Student>()
diff --git a/src/NHibernate.Test/SystemTransactions/TransactionNotificationFixture.cs b/src/NHibernate.Test/SystemTransactions/TransactionNotificationFixture.cs
@@ -164,9 +164,11 @@ public void ShouldNotifyAfterDistributedTransaction(bool doCommit)
 			Assert.That(interceptor.afterTransactionCompletionCalled, Is.EqualTo(2));
 		}
 
-
 		[Description("NH2128")]
 		[Theory]
+#if NETCOREAPP2_0
+		[Ignore("This platform does not support distributed transactions.")]
+#endif
 		public void ShouldNotifyAfterDistributedTransactionWithOwnConnection(bool doCommit)
 		{
 			// Note: For system transaction, calling Close() on the session isn't

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,9 @@ protected override void Configure(Configuration configuration)`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`[Test]`
	`40`	`+#if NETCOREAPP2_0`
	`41`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`42`	`+#endif`
`40`	`43`	`public async Task When_using_DTC_HiLo_knows_to_create_isolated_DTC_transactionAsync()`
`41`	`44`	`{`
`42`	`45`	`if (!Dialect.SupportsConcurrentWritingConnections)`
`@@ -76,8 +79,10 @@ public async Task When_using_DTC_HiLo_knows_to_create_isolated_DTC_transactionAs`
`76`	`79`	`Assert.AreNotEqual(scalar1, scalar2, "HiLo must run with in its own transaction");`
`77`	`80`	`}`
`78`	`81`
`79`		`-`
`80`	`82`	`[Test]`
	`83`	`+#if NETCOREAPP2_0`
	`84`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`85`	`+#endif`
`81`	`86`	`public async Task When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_level_cacheAsync()`
`82`	`87`	`{`
`83`	`88`	`using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))`
`@@ -131,6 +136,9 @@ public async Task When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_`
`131`	`136`	`}`
`132`	`137`
`133`	`138`	`[Test]`
	`139`	`+#if NETCOREAPP2_0`
	`140`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`141`	`+#endif`
`134`	`142`	`public async Task When_committing_transaction_scope_will_commit_transactionAsync()`
`135`	`143`	`{`
`136`	`144`	`object id;`
`@@ -178,6 +186,9 @@ public async Task Will_not_save_when_flush_mode_is_neverAsync()`
`178`	`186`	`}`
`179`	`187`
`180`	`188`	`[Test]`
	`189`	`+#if NETCOREAPP2_0`
	`190`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`191`	`+#endif`
`181`	`192`	`public async Task When_using_two_sessions_with_explicit_flushAsync()`
`182`	`193`	`{`
`183`	`194`	`if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)`
`@@ -218,6 +229,9 @@ public async Task When_using_two_sessions_with_explicit_flushAsync()`
`218`	`229`	`}`
`219`	`230`
`220`	`231`	`[Test]`
	`232`	`+#if NETCOREAPP2_0`
	`233`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`234`	`+#endif`
`221`	`235`	`public async Task When_using_two_sessionsAsync()`
`222`	`236`	`{`
`223`	`237`	`if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,9 @@ namespace NHibernate.Test.NHSpecificTest.NH2057`
`19`	`19`	`public class FixtureAsync : BugTestCase`
`20`	`20`	`{`
`21`	`21`	`[Test]`
	`22`	`+#if NETCOREAPP2_0`
	`23`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`24`	`+#endif`
`22`	`25`	`public async Task WillCloseWhenUsingDTCAsync()`
`23`	`26`	`{`
`24`	`27`	`ISession s;`
Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,9 @@ protected override void OnTearDown()`
`56`	`56`	`// Whilst this bug seems specific to Oracle I think it is valid to run the`
`57`	`57`	`// test against all database types.`
`58`	`58`	`[Test]`
	`59`	`+#if NETCOREAPP2_0`
	`60`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`61`	`+#endif`
`59`	`62`	`public async Task MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSessionAsync()`
`60`	`63`	`{`
`61`	`64`	`using (var s = OpenSession())`
`@@ -84,4 +87,4 @@ public async Task MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSess`
`84`	`87`	`}`
`85`	`88`	`}`
`86`	`89`	`}`
`87`		`-}`
	`90`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,9 @@ private string FetchConnectionStringFromConfiguration()`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`[Test]`
	`64`	`+#if NETCOREAPP2_0`
	`65`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`66`	`+#endif`
`64`	`67`	`public async Task ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransactionAsync()`
`65`	`68`	`{`
`66`	`69`	`string connectionString = FetchConnectionStringFromConfiguration();`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,11 @@ public async Task ShouldAutoFlushWhenInExplicitTransactionAsync()`
`61`	`61`	`Assert.That(result.Count, Is.EqualTo(1));`
`62`	`62`	`}`
`63`	`63`	`}`
	`64`	`+`
`64`	`65`	`[Test]`
	`66`	`+#if NETCOREAPP2_0`
	`67`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`68`	`+#endif`
`65`	`69`	`public async Task ShouldAutoFlushWhenInDistributedTransactionAsync()`
`66`	`70`	`{`
`67`	`71`	`using (new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))`
Original file line number	Diff line number	Diff line change
`@@ -1066,6 +1066,9 @@ public async Task SubselectAsync()`
`1066`	`1066`	`}`
`1067`	`1067`
`1068`	`1068`	`[Test]`
	`1069`	`+#if NETCOREAPP2_0`
	`1070`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`1071`	`+#endif`
`1069`	`1072`	`public async Task DetachedCriteriaAsync()`
`1070`	`1073`	`{`
`1071`	`1074`	`DetachedCriteria dc = NHibernate.Criterion.DetachedCriteria.For<Student>()`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,9 @@ protected override void Configure(Configuration configuration)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`[Test]`
	`28`	`+#if NETCOREAPP2_0`
	`29`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`30`	`+#endif`
`28`	`31`	`public void When_using_DTC_HiLo_knows_to_create_isolated_DTC_transaction()`
`29`	`32`	`{`
`30`	`33`	`if (!Dialect.SupportsConcurrentWritingConnections)`
`@@ -81,8 +84,10 @@ public void Dispose_session_inside_transaction_scope()`
`81`	`84`	`Assert.IsFalse(s.IsOpen);`
`82`	`85`	`}`
`83`	`86`
`84`		`-`
`85`	`87`	`[Test]`
	`88`	`+#if NETCOREAPP2_0`
	`89`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`90`	`+#endif`
`86`	`91`	`public void When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_level_cache()`
`87`	`92`	`{`
`88`	`93`	`using (var tx = new TransactionScope())`
`@@ -136,6 +141,9 @@ public void When_commiting_items_in_DTC_transaction_will_add_items_to_2nd_level_`
`136`	`141`	`}`
`137`	`142`
`138`	`143`	`[Test]`
	`144`	`+#if NETCOREAPP2_0`
	`145`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`146`	`+#endif`
`139`	`147`	`public void When_committing_transaction_scope_will_commit_transaction()`
`140`	`148`	`{`
`141`	`149`	`object id;`
`@@ -183,6 +191,9 @@ public void Will_not_save_when_flush_mode_is_never()`
`183`	`191`	`}`
`184`	`192`
`185`	`193`	`[Test]`
	`194`	`+#if NETCOREAPP2_0`
	`195`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`196`	`+#endif`
`186`	`197`	`public void When_using_two_sessions_with_explicit_flush()`
`187`	`198`	`{`
`188`	`199`	`if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)`
`@@ -223,6 +234,9 @@ public void When_using_two_sessions_with_explicit_flush()`
`223`	`234`	`}`
`224`	`235`
`225`	`236`	`[Test]`
	`237`	`+#if NETCOREAPP2_0`
	`238`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`239`	`+#endif`
`226`	`240`	`public void When_using_two_sessions()`
`227`	`241`	`{`
`228`	`242`	`if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@ namespace NHibernate.Test.NHSpecificTest.NH2057`
`8`	`8`	`public class Fixture : BugTestCase`
`9`	`9`	`{`
`10`	`10`	`[Test]`
	`11`	`+#if NETCOREAPP2_0`
	`12`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`13`	`+#endif`
`11`	`14`	`public void WillCloseWhenUsingDTC()`
`12`	`15`	`{`
`13`	`16`	`ISession s;`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,9 @@ protected override void OnTearDown()`
`45`	`45`	`// Whilst this bug seems specific to Oracle I think it is valid to run the`
`46`	`46`	`// test against all database types.`
`47`	`47`	`[Test]`
	`48`	`+#if NETCOREAPP2_0`
	`49`	`+ [Ignore("This platform does not support distributed transactions.")]`
	`50`	`+#endif`
`48`	`51`	`public void MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSession()`
`49`	`52`	`{`
`50`	`53`	`using (var s = OpenSession())`
`@@ -73,4 +76,4 @@ public void MultipleConsecutiveTransactionScopesCanBeUsedInsideASingleSession()`
`73`	`76`	`}`
`74`	`77`	`}`
`75`	`78`	`}`
`76`		`-}`
	`79`	`+}`