Refactor test

bahusoid · bahusoid · commit 0c8f1209f57b · 2022-04-04T16:01:32.000+03:00
diff --git a/src/NHibernate.Test/Async/NHSpecificTest/GH1235/OptionalJoinFixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/GH1235/OptionalJoinFixture.cs
@@ -19,14 +19,14 @@ namespace NHibernate.Test.NHSpecificTest.GH1235
 {
 	using System.Threading.Tasks;
 	//NH-2785
-	[TestFixture(true, "OptimisticLock")]
-	[TestFixture(false, "Version")]
-	[TestFixture(null, "NotVersioned")]
+	[TestFixture(OptimisticLockMode.None)]
+	[TestFixture(OptimisticLockMode.Version)]
+	[TestFixture(OptimisticLockMode.Dirty)]
 	public class OptionalJoinFixtureAsync : TestCaseMappingByCode
 	{
-		private readonly bool? _optimisticLock;
+		private readonly OptimisticLockMode _optimisticLock;
 
-		public OptionalJoinFixtureAsync(bool? optimisticLock, string comment)
+		public OptionalJoinFixtureAsync(OptimisticLockMode optimisticLock)
 		{
 			_optimisticLock = optimisticLock;
 		}
@@ -104,7 +104,6 @@ public async Task ShouldThrowStaleStateForOptimisticLockUpdateAsync()
 		{
 			using (var s = OpenSession())
 			using (var t = s.BeginTransaction())
-
 			{
 				var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };
 				await (s.SaveAsync(result));
@@ -124,11 +123,11 @@ public async Task ShouldThrowStaleStateForOptimisticLockUpdateAsync()
 					await (t1.CommitAsync());
 
 					using (var t2 = s2.BeginTransaction())
-					Assert.That(
-						() => t2.CommitAsync(),
-						_optimisticLock == null
-							? (IResolveConstraint) Throws.Nothing
-							: Throws.InstanceOf<StaleObjectStateException>());
+						Assert.That(
+							() => t2.CommitAsync(),
+							_optimisticLock == OptimisticLockMode.None
+								? (IResolveConstraint) Throws.Nothing
+								: Throws.InstanceOf<StaleObjectStateException>());
 				}
 			}
 		}
@@ -138,7 +137,6 @@ public async Task ShouldThrowStaleStateForOptimisticLockDeleteAsync()
 		{
 			using (var s = OpenSession())
 			using (var t = s.BeginTransaction())
-
 			{
 				var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };
 				await (s.SaveAsync(result));
@@ -158,11 +156,11 @@ public async Task ShouldThrowStaleStateForOptimisticLockDeleteAsync()
 					await (t1.CommitAsync());
 
 					using (var t2 = s2.BeginTransaction())
-					Assert.That(
-						() => t2.CommitAsync(),
-						_optimisticLock == null
-							? (IResolveConstraint) Throws.Nothing
-							: Throws.InstanceOf<StaleObjectStateException>());
+						Assert.That(
+							() => t2.CommitAsync(),
+							_optimisticLock == OptimisticLockMode.None
+								? (IResolveConstraint) Throws.Nothing
+								: Throws.InstanceOf<StaleObjectStateException>());
 				}
 			}
 		}
@@ -175,10 +173,9 @@ protected override HbmMapping GetMappings()
 				{
 					rc.Id(x => x.Id, m => m.Generator(Generators.Native));
 					rc.DynamicUpdate(true);
+					rc.OptimisticLock(_optimisticLock);
 
-					if (_optimisticLock == true)
-						rc.OptimisticLock(OptimisticLockMode.Dirty);
-					else if (_optimisticLock != null)
+					if (_optimisticLock == OptimisticLockMode.Version)
 						rc.Version(x => x.Version, _ => { });
 
 					rc.Property(x => x.Name);
diff --git a/src/NHibernate.Test/NHSpecificTest/GH1235/OptionalJoinFixture.cs b/src/NHibernate.Test/NHSpecificTest/GH1235/OptionalJoinFixture.cs
@@ -7,14 +7,14 @@
 namespace NHibernate.Test.NHSpecificTest.GH1235
 {
 	//NH-2785
-	[TestFixture(true, "OptimisticLock")]
-	[TestFixture(false, "Version")]
-	[TestFixture(null, "NotVersioned")]
+	[TestFixture(OptimisticLockMode.None)]
+	[TestFixture(OptimisticLockMode.Version)]
+	[TestFixture(OptimisticLockMode.Dirty)]
 	public class OptionalJoinFixture : TestCaseMappingByCode
 	{
-		private readonly bool? _optimisticLock;
+		private readonly OptimisticLockMode _optimisticLock;
 
-		public OptionalJoinFixture(bool? optimisticLock, string comment)
+		public OptionalJoinFixture(OptimisticLockMode optimisticLock)
 		{
 			_optimisticLock = optimisticLock;
 		}
@@ -92,7 +92,6 @@ public void ShouldThrowStaleStateForOptimisticLockUpdate()
 		{
 			using (var s = OpenSession())
 			using (var t = s.BeginTransaction())
-
 			{
 				var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };
 				s.Save(result);
@@ -112,11 +111,11 @@ public void ShouldThrowStaleStateForOptimisticLockUpdate()
 					t1.Commit();
 
 					using (var t2 = s2.BeginTransaction())
-					Assert.That(
-						() => t2.Commit(),
-						_optimisticLock == null
-							? (IResolveConstraint) Throws.Nothing
-							: Throws.InstanceOf<StaleObjectStateException>());
+						Assert.That(
+							() => t2.Commit(),
+							_optimisticLock == OptimisticLockMode.None
+								? (IResolveConstraint) Throws.Nothing
+								: Throws.InstanceOf<StaleObjectStateException>());
 				}
 			}
 		}
@@ -126,7 +125,6 @@ public void ShouldThrowStaleStateForOptimisticLockDelete()
 		{
 			using (var s = OpenSession())
 			using (var t = s.BeginTransaction())
-
 			{
 				var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };
 				s.Save(result);
@@ -146,11 +144,11 @@ public void ShouldThrowStaleStateForOptimisticLockDelete()
 					t1.Commit();
 
 					using (var t2 = s2.BeginTransaction())
-					Assert.That(
-						() => t2.Commit(),
-						_optimisticLock == null
-							? (IResolveConstraint) Throws.Nothing
-							: Throws.InstanceOf<StaleObjectStateException>());
+						Assert.That(
+							() => t2.Commit(),
+							_optimisticLock == OptimisticLockMode.None
+								? (IResolveConstraint) Throws.Nothing
+								: Throws.InstanceOf<StaleObjectStateException>());
 				}
 			}
 		}
@@ -163,10 +161,9 @@ protected override HbmMapping GetMappings()
 				{
 					rc.Id(x => x.Id, m => m.Generator(Generators.Native));
 					rc.DynamicUpdate(true);
+					rc.OptimisticLock(_optimisticLock);
 
-					if (_optimisticLock == true)
-						rc.OptimisticLock(OptimisticLockMode.Dirty);
-					else if (_optimisticLock != null)
+					if (_optimisticLock == OptimisticLockMode.Version)
 						rc.Version(x => x.Version, _ => { });
 
 					rc.Property(x => x.Name);

Original file line number	Diff line number	Diff line change
`@@ -19,14 +19,14 @@ namespace NHibernate.Test.NHSpecificTest.GH1235`
`19`	`19`	`{`
`20`	`20`	`using System.Threading.Tasks;`
`21`	`21`	`//NH-2785`
`22`		`- [TestFixture(true, "OptimisticLock")]`
`23`		`- [TestFixture(false, "Version")]`
`24`		`- [TestFixture(null, "NotVersioned")]`
	`22`	`+ [TestFixture(OptimisticLockMode.None)]`
	`23`	`+ [TestFixture(OptimisticLockMode.Version)]`
	`24`	`+ [TestFixture(OptimisticLockMode.Dirty)]`
`25`	`25`	`public class OptionalJoinFixtureAsync : TestCaseMappingByCode`
`26`	`26`	`{`
`27`		`- private readonly bool? _optimisticLock;`
	`27`	`+ private readonly OptimisticLockMode _optimisticLock;`
`28`	`28`
`29`		`- public OptionalJoinFixtureAsync(bool? optimisticLock, string comment)`
	`29`	`+ public OptionalJoinFixtureAsync(OptimisticLockMode optimisticLock)`
`30`	`30`	`{`
`31`	`31`	`_optimisticLock = optimisticLock;`
`32`	`32`	`}`
`@@ -104,7 +104,6 @@ public async Task ShouldThrowStaleStateForOptimisticLockUpdateAsync()`
`104`	`104`	`{`
`105`	`105`	`using (var s = OpenSession())`
`106`	`106`	`using (var t = s.BeginTransaction())`
`107`		`-`
`108`	`107`	`{`
`109`	`108`	`var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };`
`110`	`109`	`await (s.SaveAsync(result));`
`@@ -124,11 +123,11 @@ public async Task ShouldThrowStaleStateForOptimisticLockUpdateAsync()`
`124`	`123`	`await (t1.CommitAsync());`
`125`	`124`
`126`	`125`	`using (var t2 = s2.BeginTransaction())`
`127`		`- Assert.That(`
`128`		`- () => t2.CommitAsync(),`
`129`		`- _optimisticLock == null`
`130`		`- ? (IResolveConstraint) Throws.Nothing`
`131`		`- : Throws.InstanceOf<StaleObjectStateException>());`
	`126`	`+ Assert.That(`
	`127`	`+ () => t2.CommitAsync(),`
	`128`	`+ _optimisticLock == OptimisticLockMode.None`
	`129`	`+ ? (IResolveConstraint) Throws.Nothing`
	`130`	`+ : Throws.InstanceOf<StaleObjectStateException>());`
`132`	`131`	`}`
`133`	`132`	`}`
`134`	`133`	`}`
`@@ -138,7 +137,6 @@ public async Task ShouldThrowStaleStateForOptimisticLockDeleteAsync()`
`138`	`137`	`{`
`139`	`138`	`using (var s = OpenSession())`
`140`	`139`	`using (var t = s.BeginTransaction())`
`141`		`-`
`142`	`140`	`{`
`143`	`141`	`var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };`
`144`	`142`	`await (s.SaveAsync(result));`
`@@ -158,11 +156,11 @@ public async Task ShouldThrowStaleStateForOptimisticLockDeleteAsync()`
`158`	`156`	`await (t1.CommitAsync());`
`159`	`157`
`160`	`158`	`using (var t2 = s2.BeginTransaction())`
`161`		`- Assert.That(`
`162`		`- () => t2.CommitAsync(),`
`163`		`- _optimisticLock == null`
`164`		`- ? (IResolveConstraint) Throws.Nothing`
`165`		`- : Throws.InstanceOf<StaleObjectStateException>());`
	`159`	`+ Assert.That(`
	`160`	`+ () => t2.CommitAsync(),`
	`161`	`+ _optimisticLock == OptimisticLockMode.None`
	`162`	`+ ? (IResolveConstraint) Throws.Nothing`
	`163`	`+ : Throws.InstanceOf<StaleObjectStateException>());`
`166`	`164`	`}`
`167`	`165`	`}`
`168`	`166`	`}`
`@@ -175,10 +173,9 @@ protected override HbmMapping GetMappings()`
`175`	`173`	`{`
`176`	`174`	`rc.Id(x => x.Id, m => m.Generator(Generators.Native));`
`177`	`175`	`rc.DynamicUpdate(true);`
	`176`	`+ rc.OptimisticLock(_optimisticLock);`
`178`	`177`
`179`		`- if (_optimisticLock == true)`
`180`		`- rc.OptimisticLock(OptimisticLockMode.Dirty);`
`181`		`- else if (_optimisticLock != null)`
	`178`	`+ if (_optimisticLock == OptimisticLockMode.Version)`
`182`	`179`	`rc.Version(x => x.Version, _ => { });`
`183`	`180`
`184`	`181`	`rc.Property(x => x.Name);`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@`
`7`	`7`	`namespace NHibernate.Test.NHSpecificTest.GH1235`
`8`	`8`	`{`
`9`	`9`	`//NH-2785`
`10`		`- [TestFixture(true, "OptimisticLock")]`
`11`		`- [TestFixture(false, "Version")]`
`12`		`- [TestFixture(null, "NotVersioned")]`
	`10`	`+ [TestFixture(OptimisticLockMode.None)]`
	`11`	`+ [TestFixture(OptimisticLockMode.Version)]`
	`12`	`+ [TestFixture(OptimisticLockMode.Dirty)]`
`13`	`13`	`public class OptionalJoinFixture : TestCaseMappingByCode`
`14`	`14`	`{`
`15`		`- private readonly bool? _optimisticLock;`
	`15`	`+ private readonly OptimisticLockMode _optimisticLock;`
`16`	`16`
`17`		`- public OptionalJoinFixture(bool? optimisticLock, string comment)`
	`17`	`+ public OptionalJoinFixture(OptimisticLockMode optimisticLock)`
`18`	`18`	`{`
`19`	`19`	`_optimisticLock = optimisticLock;`
`20`	`20`	`}`
`@@ -92,7 +92,6 @@ public void ShouldThrowStaleStateForOptimisticLockUpdate()`
`92`	`92`	`{`
`93`	`93`	`using (var s = OpenSession())`
`94`	`94`	`using (var t = s.BeginTransaction())`
`95`		`-`
`96`	`95`	`{`
`97`	`96`	`var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };`
`98`	`97`	`s.Save(result);`
`@@ -112,11 +111,11 @@ public void ShouldThrowStaleStateForOptimisticLockUpdate()`
`112`	`111`	`t1.Commit();`
`113`	`112`
`114`	`113`	`using (var t2 = s2.BeginTransaction())`
`115`		`- Assert.That(`
`116`		`- () => t2.Commit(),`
`117`		`- _optimisticLock == null`
`118`		`- ? (IResolveConstraint) Throws.Nothing`
`119`		`- : Throws.InstanceOf<StaleObjectStateException>());`
	`114`	`+ Assert.That(`
	`115`	`+ () => t2.Commit(),`
	`116`	`+ _optimisticLock == OptimisticLockMode.None`
	`117`	`+ ? (IResolveConstraint) Throws.Nothing`
	`118`	`+ : Throws.InstanceOf<StaleObjectStateException>());`
`120`	`119`	`}`
`121`	`120`	`}`
`122`	`121`	`}`
`@@ -126,7 +125,6 @@ public void ShouldThrowStaleStateForOptimisticLockDelete()`
`126`	`125`	`{`
`127`	`126`	`using (var s = OpenSession())`
`128`	`127`	`using (var t = s.BeginTransaction())`
`129`		`-`
`130`	`128`	`{`
`131`	`129`	`var result = new MultiTableEntity { Name = "Bob", OtherName = "Bob" };`
`132`	`130`	`s.Save(result);`
`@@ -146,11 +144,11 @@ public void ShouldThrowStaleStateForOptimisticLockDelete()`
`146`	`144`	`t1.Commit();`
`147`	`145`
`148`	`146`	`using (var t2 = s2.BeginTransaction())`
`149`		`- Assert.That(`
`150`		`- () => t2.Commit(),`
`151`		`- _optimisticLock == null`
`152`		`- ? (IResolveConstraint) Throws.Nothing`
`153`		`- : Throws.InstanceOf<StaleObjectStateException>());`
	`147`	`+ Assert.That(`
	`148`	`+ () => t2.Commit(),`
	`149`	`+ _optimisticLock == OptimisticLockMode.None`
	`150`	`+ ? (IResolveConstraint) Throws.Nothing`
	`151`	`+ : Throws.InstanceOf<StaleObjectStateException>());`
`154`	`152`	`}`
`155`	`153`	`}`
`156`	`154`	`}`
`@@ -163,10 +161,9 @@ protected override HbmMapping GetMappings()`
`163`	`161`	`{`
`164`	`162`	`rc.Id(x => x.Id, m => m.Generator(Generators.Native));`
`165`	`163`	`rc.DynamicUpdate(true);`
	`164`	`+ rc.OptimisticLock(_optimisticLock);`
`166`	`165`
`167`		`- if (_optimisticLock == true)`
`168`		`- rc.OptimisticLock(OptimisticLockMode.Dirty);`
`169`		`- else if (_optimisticLock != null)`
	`166`	`+ if (_optimisticLock == OptimisticLockMode.Version)`
`170`	`167`	`rc.Version(x => x.Version, _ => { });`
`171`	`168`
`172`	`169`	`rc.Property(x => x.Name);`