Support multitenancy in id generators

src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs

@@ -8,16 +8,20 @@
 //------------------------------------------------------------------------------
 
 
-using NUnit.Framework;
 using NHibernate.Id.Enhanced;
-using System.Collections;
+using NHibernate.Test.MultiTenancy;
+using NUnit.Framework;
 
 namespace NHibernate.Test.IdGen.Enhanced.Forcedtable
 {
 	using System.Threading.Tasks;
-	[TestFixture]
-	public class HiLoForcedTableSequenceTestAsync : TestCase
+	[TestFixture(null)]
+	[TestFixture("test")]
+	public class HiLoForcedTableSequenceTestAsync : TestCaseWithMultiTenancy
 	{
+		public HiLoForcedTableSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier)
+		{
+		}
 		protected override string[] Mappings
 		{
 			get { return new[] { "IdGen.Enhanced.Forcedtable.HiLo.hbm.xml" }; }
@@ -54,19 +58,31 @@ public async Task TestNormalBoundaryAsync()
 						long expectedId = i + 1;
 						Assert.That(entities[i].Id, Is.EqualTo(expectedId));
 						Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
-						Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1));
+						if (TenantIdentifier == null)
+						{
+							Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
+							Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+							Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1));
+						}
+						Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization
+						Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1));
+						Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1));
 					}
 
 					// now force a "clock over"
 					entities[increment] = new Entity("" + increment);
 					await (session.SaveAsync(entities[increment]));
 					Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1));
 					Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization + clock-over
-					Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over
-					Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
-					Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1));
+					if (TenantIdentifier == null)
+					{
+						Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over
+						Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+						Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1));
+					}
+					Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); // initialization + clock-over
+					Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1));
+					Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1));
 
 					await (transaction.CommitAsync());
 				}
@@ -85,4 +101,4 @@ public async Task TestNormalBoundaryAsync()
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs

@@ -8,16 +8,20 @@
 //------------------------------------------------------------------------------
 
 
-using NUnit.Framework;
 using NHibernate.Id.Enhanced;
-using System.Collections;
+using NHibernate.Test.MultiTenancy;
+using NUnit.Framework;
 
 namespace NHibernate.Test.IdGen.Enhanced.Forcedtable
 {
 	using System.Threading.Tasks;
-	[TestFixture]
-	public class PooledForcedTableSequenceTestAsync : TestCase
+	[TestFixture(null)]
+	[TestFixture("test")]
+	public class PooledForcedTableSequenceTestAsync : TestCaseWithMultiTenancy
 	{
+		public PooledForcedTableSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier)
+		{
+		}
 		protected override string[] Mappings
 		{
 			get { return new[] { "IdGen.Enhanced.Forcedtable.Pooled.hbm.xml" }; }
@@ -55,8 +59,13 @@ public async Task TestNormalBoundaryAsync()
 						Assert.That(entities[i].Id, Is.EqualTo(expectedId));
 						// NOTE : initialization calls table twice
 						Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization
-						Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization
-						Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+						if (TenantIdentifier == null)
+						{
+							Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization
+							Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+						}
+						Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization
+						Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1));
 					}
 
 					// now force a "clock over"
@@ -66,8 +75,14 @@ public async Task TestNormalBoundaryAsync()
 					Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1));
 					// initialization (2) + clock over
 					Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3));
-					Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment*2 + 1));
-					Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+					if (TenantIdentifier == null)
+					{
+						Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1));
+						Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+					}
+					Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1));
+					Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1));
+
 
 					await (transaction.CommitAsync());
 				}
@@ -86,4 +101,4 @@ public async Task TestNormalBoundaryAsync()
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs

@@ -8,8 +8,8 @@
 //------------------------------------------------------------------------------
 
 
-using NUnit.Framework;
 using NHibernate.Id.Enhanced;
+using NUnit.Framework;
 
 namespace NHibernate.Test.IdGen.Enhanced
 {

src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs

@@ -11,13 +11,18 @@
 using System.Collections;
 using NUnit.Framework;
 using NHibernate.Id.Enhanced;
+using NHibernate.Test.MultiTenancy;
 
 namespace NHibernate.Test.IdGen.Enhanced.Sequence
 {
 	using System.Threading.Tasks;
-	[TestFixture]
-	public class HiLoSequenceTestAsync : TestCase
+	[TestFixture(null)]
+	[TestFixture("test")]
+	public class HiLoSequenceTestAsync : TestCaseWithMultiTenancy
 	{
+		public HiLoSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier)
+		{
+		}
 		protected override string[] Mappings
 		{
 			get { return new[] { "IdGen.Enhanced.Sequence.HiLo.hbm.xml" }; }
@@ -51,18 +56,30 @@ public async Task TestNormalBoundaryAsync()
 						entities[i] = new Entity("" + (i + 1));
 						await (session.SaveAsync(entities[i]));
 						Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
-						Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1));
+						if (TenantIdentifier == null)
+						{
+							Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
+							Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+							Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1));
+						}
+						Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization
+						Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1));
+						Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1));
 					}
 
 					// now force a "clock over"
 					entities[increment] = new Entity("" + increment);
 					await (session.SaveAsync(entities[increment]));
 					Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2));
-					Assert.That(optimizer.LastSourceValue, Is.EqualTo(2));
-					Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
-					Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1));
+					if (TenantIdentifier == null)
+					{
+						Assert.That(optimizer.LastSourceValue, Is.EqualTo(2));
+						Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+						Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1));
+					}
+					Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2));
+					Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1));
+					Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1));
 
 					await (transaction.CommitAsync());
 				}
@@ -80,4 +97,4 @@ public async Task TestNormalBoundaryAsync()
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs

@@ -8,16 +8,20 @@
 //------------------------------------------------------------------------------
 
 
-using System.Collections;
-using NUnit.Framework;
 using NHibernate.Id.Enhanced;
+using NHibernate.Test.MultiTenancy;
+using NUnit.Framework;
 
 namespace NHibernate.Test.IdGen.Enhanced.Sequence
 {
 	using System.Threading.Tasks;
-	[TestFixture]
-	public class PooledSequenceTestAsync : TestCase
+	[TestFixture(null)]
+	[TestFixture("test")]
+	public class PooledSequenceTestAsync : TestCaseWithMultiTenancy
 	{
+		public PooledSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier)
+		{
+		}
 		protected override string[] Mappings
 		{
 			get { return new[] { "IdGen.Enhanced.Sequence.Pooled.hbm.xml" }; }
@@ -51,16 +55,26 @@ public async Task TestNormalBoundaryAsync()
 						entities[i] = new Entity("" + (i + 1));
 						await (session.SaveAsync(entities[i]));
 						Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization calls seq twice
-						Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice
-						Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+						if (TenantIdentifier == null)
+						{
+							Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice
+							Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+						}
+						Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice
+						Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1));
 					}
 
 					// now force a "clock over"
 					entities[increment] = new Entity("" + increment);
 					await (session.SaveAsync(entities[increment]));
 					Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); // initialization (2) + clock over
-					Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over
-					Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+					if (TenantIdentifier == null)
+					{
+						Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over
+						Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+					}
+					Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over
+					Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1));
 
 					await (transaction.CommitAsync());
 				}
@@ -79,4 +93,4 @@ public async Task TestNormalBoundaryAsync()
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs

@@ -46,4 +46,4 @@ public Task<long> GetNextValueAsync(CancellationToken cancellationToken)
 			}
 		}
 	}
-}
+}

src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs

@@ -10,14 +10,19 @@
 
 using System.Collections;
 using NHibernate.Id.Enhanced;
+using NHibernate.Test.MultiTenancy;
 using NUnit.Framework;
 
 namespace NHibernate.Test.IdGen.Enhanced.Table
 {
 	using System.Threading.Tasks;
-	[TestFixture]
-	public class HiLoTableTestAsync : TestCase
+	[TestFixture(null)]
+	[TestFixture("test")]
+	public class HiLoTableTestAsync : TestCaseWithMultiTenancy
 	{
+		public HiLoTableTestAsync(string tenantIdentifier) : base(tenantIdentifier)
+		{
+		}
 		protected override string[] Mappings
 		{
 			get { return new[] { "IdGen.Enhanced.Table.HiLo.hbm.xml" }; }
@@ -50,18 +55,30 @@ public async Task TestNormalBoundaryAsync()
 						entities[i] = new Entity("" + (i + 1));
 						await (s.SaveAsync(entities[i]));
 						Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
-						Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1));
+						if (TenantIdentifier == null)
+						{
+							Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
+							Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+							Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1));
+						}
+						Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization
+						Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1));
+						Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1));
 					}
 
 					// now force a "clock over"
 					entities[increment] = new Entity("" + increment);
 					await (s.SaveAsync(entities[increment]));
 					Assert.That(generator.TableAccessCount, Is.EqualTo(2));
-					Assert.That(optimizer.LastSourceValue, Is.EqualTo(2));
-					Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
-					Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1));
+					if (TenantIdentifier == null)
+					{
+						Assert.That(optimizer.LastSourceValue, Is.EqualTo(2));
+						Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+						Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1));
+					}
+					Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2));
+					Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1));
+					Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1));
 					await (transaction.CommitAsync());
 				}
 

src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs

@@ -10,14 +10,19 @@
 
 using System.Collections;
 using NHibernate.Id.Enhanced;
+using NHibernate.Test.MultiTenancy;
 using NUnit.Framework;
 
 namespace NHibernate.Test.IdGen.Enhanced.Table
 {
 	using System.Threading.Tasks;
-	[TestFixture]
-	public class PooledLoTableTestAsync : TestCase
+	[TestFixture(null)]
+	[TestFixture("test")]
+	public class PooledLoTableTestAsync : TestCaseWithMultiTenancy
 	{
+		public PooledLoTableTestAsync(string tenantIdentifier) : base(tenantIdentifier)
+		{
+		}
 		protected override string[] Mappings
 		{
 			get { return new[] { "IdGen.Enhanced.Table.PooledLo.hbm.xml" }; }
@@ -50,16 +55,26 @@ public async Task TestNormalBoundaryAsync()
 						entities[i] = new Entity("" + (i + 1));
 						await (s.SaveAsync(entities[i]));
 						Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
-						Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+						if (TenantIdentifier == null)
+						{
+							Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization
+							Assert.That(optimizer.LastValue, Is.EqualTo(i + 1));
+						}
+						Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization
+						Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1));
 					}
 
 					// now force a "clock over"
 					entities[increment] = new Entity("" + increment);
 					await (s.SaveAsync(entities[increment]));
 					Assert.That(generator.TableAccessCount, Is.EqualTo(2));
-					Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1));
-					Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+					if (TenantIdentifier == null)
+					{
+						Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1));
+						Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1));
+					}
+					Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1));
+					Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1));
 
 					await (transaction.CommitAsync());
 				}