Fix loop detection for associations with fetch="join" mapping

src/NHibernate.Test/Async/Immutable/EntityWithMutableCollection/AbstractEntityWithOneToManyTest.cs

@@ -1234,7 +1234,6 @@ public virtual async Task OneToManyCollectionOptimisticLockingWithUpdateAsync()
 
 			s = OpenSession();
 			t = s.BeginTransaction();
-			c = await (s.CreateCriteria<Contract>().UniqueResultAsync<Contract>());
 			// If the entity uses a join mapping, DML queries require temp tables.
 			if (Dialect.SupportsTemporaryTables)
 				await (s.CreateQuery("delete from Party").ExecuteUpdateAsync());
@@ -1251,7 +1250,7 @@ public virtual async Task OneToManyCollectionOptimisticLockingWithUpdateAsync()
 				await (s.DeleteAsync(partyOrig));
 				await (s.DeleteAsync(newParty));
 			}
-
+			c = await (s.CreateCriteria<Contract>().UniqueResultAsync<Contract>());
 			await (s.DeleteAsync(c));
 			Assert.That(await (s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync<long>()), Is.EqualTo(0L));
 			Assert.That(await (s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync<long>()), Is.EqualTo(0L));

src/NHibernate.Test/Async/NHSpecificTest/GH2201/CircularReferenceFetchDepth0Fixture.cs

@@ -0,0 +1,66 @@
+//------------------------------------------------------------------------------
+// <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.Cfg;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH2201
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class CircularReferenceFetchDepth0FixtureAsync : BaseFetchFixture
+	{
+		private int _id2;
+
+		public CircularReferenceFetchDepth0FixtureAsync() : base(0)
+		{
+		}
+
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty("max_fetch_depth", "0");
+			base.Configure(configuration);
+		}
+
+		protected override void OnSetUp()
+		{
+			base.OnSetUp();
+			_id2 = _id;
+			//Generate another test entity
+			base.OnSetUp();
+		}
+
+		[Test]
+		public async Task QueryOverAsync()
+		{
+			using (var session = OpenSession())
+			{
+				Entity e1 = null;
+				Entity e2 = null;
+				var result = await (session.QueryOver<Entity>(() => e1)
+					.JoinEntityAlias(() => e2, () => e2.EntityNumber == e1.EntityNumber && e2.EntityId != _id)
+					.Where(e => e.EntityId == _id).SingleOrDefaultAsync());
+
+				VerifyChildrenNotInitialized(result);
+				VerifyChildrenNotInitialized(await (session.LoadAsync<Entity>(_id2)));
+			}
+		}
+
+		[Test]
+		public async Task GetAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var result = await (session.GetAsync<Entity>(_id));
+				VerifyChildrenNotInitialized(result);
+			}
+		}
+	}
+}

src/NHibernate.Test/Async/NHSpecificTest/GH2201/CircularReferenceFetchDepthFixture.cs

@@ -0,0 +1,75 @@
+//------------------------------------------------------------------------------
+// <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.Cfg;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH2201
+{
+	using System.Threading.Tasks;
+	[TestFixture(1)]
+	[TestFixture(2)]
+	public class CircularReferenceFetchDepthFixtureAsync : BaseFetchFixture
+	{
+		private int _id2;
+		private int _id3;
+
+		public CircularReferenceFetchDepthFixtureAsync(int depth) : base(depth)
+		{
+		}
+
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty("max_fetch_depth", _depth.ToString());
+			base.Configure(configuration);
+		}
+
+		protected override void OnSetUp()
+		{
+			base.OnSetUp();
+			_id2 = _id;
+
+			//Generate another test entities
+			base.OnSetUp();
+			_id3 = _id;
+			base.OnSetUp();
+		}
+
+		[Test]
+		public async Task QueryOverAsync()
+		{
+			using (var session = OpenSession())
+			{
+				Entity e1 = null;
+				Entity e2 = null;
+				Entity e3 = null;
+				var result = await (session.QueryOver<Entity>(() => e1)
+					.JoinEntityAlias(() => e2, () => e2.EntityNumber == e1.EntityNumber && e2.EntityId == _id2)
+					.JoinEntityAlias(() => e3, () => e3.EntityNumber == e1.EntityNumber && e3.EntityId == _id3)
+					.Where(e => e.EntityId == _id).SingleOrDefaultAsync());
+
+				Verify(result);
+
+				Verify(await (session.LoadAsync<Entity>(_id2)));
+				Verify(await (session.LoadAsync<Entity>(_id3)));
+			}
+		}
+
+		[Test]
+		public async Task GetAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var result = await (session.GetAsync<Entity>(_id));
+				Verify(result);
+			}
+		}
+	}
+}

src/NHibernate.Test/Async/NHSpecificTest/GH2201/CircularReferenceFetchFixture.cs

@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <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 System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH2201
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class CircularReferenceFetchFixtureAsync : BaseFetchFixture
+	{
+		public CircularReferenceFetchFixtureAsync() : base(-1)
+		{
+		}
+
+		[Test]
+		public async Task QueryOverAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var result = await (session.QueryOver<Entity>().Where(e => e.EntityNumber == "Bob").SingleOrDefaultAsync());
+
+				Verify(result);
+			}
+		}
+
+		[Test]
+		public async Task GetAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var result = await (session.GetAsync<Entity>(_id));
+
+				Verify(result);
+			}
+		}
+	}
+}

src/NHibernate.Test/Async/NHSpecificTest/GH2201/DetectFetchLoopsFalseFixture.cs

@@ -0,0 +1,130 @@
+//------------------------------------------------------------------------------
+// <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 NUnit.Framework;
+using NHCfg = NHibernate.Cfg;
+
+namespace NHibernate.Test.NHSpecificTest.GH2201
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class DetectFetchLoopsFalseFixtureAsync : BugTestCase
+	{
+		protected override void Configure(NHCfg.Configuration configuration)
+		{
+			configuration.SetProperty(NHCfg.Environment.GenerateStatistics, "true");
+			configuration.SetProperty(NHCfg.Environment.DetectFetchLoops, "false");
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				s.Delete("from Person");
+
+				tx.Commit();
+			}
+		}
+
+		protected override void OnSetUp()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				string[] names = { "Alice", "Bob" };
+
+				for (int i = 0; i < names.Length; i++)
+				{
+					var name = names[i];
+
+					var parent = new Person()
+					{
+						Name = name,
+						Details = new Detail()
+						{
+							Data = $"Details for ${name}"
+						}
+					};
+
+					for (int j = 1; j <= 3; j++)
+					{
+						var child = new Person()
+						{
+							Name = $"Child ${j} of ${parent.Name}",
+							Parent = parent,
+							Details = new Detail()
+							{
+								Data = $"Details for child ${j} of ${name}"
+							}
+						};
+
+						parent.Children.Add(child);
+					}
+
+					s.Save(parent);
+				}
+
+				tx.Commit();
+			}
+		}
+
+		[Test]
+		public async Task QueryOverPersonWithParentAsync()
+		{
+			var stats = Sfi.Statistics;
+
+			stats.Clear();
+
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var people = await (s.QueryOver<Person>()
+					.Fetch(SelectMode.Fetch, p => p.Parent)
+					.Where(p => p.Parent != null)
+					.ListAsync());
+
+				foreach (Person p in people)
+				{
+					Assert.That(p.Parent, Is.Not.Null);
+					Assert.That(p.Parent.Details, Is.Not.Null);
+				}
+
+				Assert.That(people.Count, Is.EqualTo(6));
+				Assert.That(stats.QueryExecutionCount, Is.EqualTo(1));
+				Assert.That(stats.EntityFetchCount, Is.EqualTo(0));
+				Assert.That(stats.EntityLoadCount, Is.EqualTo(16));
+			}
+		}
+
+		[Test]
+		public async Task QueryOverSinglePersonWithParentAsync()
+		{
+			var stats = Sfi.Statistics;
+
+			stats.Clear();
+
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var person = await (s.QueryOver<Person>()
+					.Where(p => p.Parent != null)
+					.Fetch(SelectMode.Fetch, p => p.Parent)
+					.Take(1)
+					.SingleOrDefaultAsync());
+
+				Assert.That(person, Is.Not.Null);
+				Assert.That(stats.QueryExecutionCount, Is.EqualTo(1));
+				Assert.That(stats.EntityFetchCount, Is.EqualTo(0));
+				Assert.That(stats.EntityLoadCount, Is.EqualTo(4));
+			}
+		}
+	}
+}

src/NHibernate.Test/Immutable/EntityWithMutableCollection/AbstractEntityWithOneToManyTest.cs

@@ -1223,7 +1223,6 @@ public virtual void OneToManyCollectionOptimisticLockingWithUpdate()
 
 			s = OpenSession();
 			t = s.BeginTransaction();
-			c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
 			// If the entity uses a join mapping, DML queries require temp tables.
 			if (Dialect.SupportsTemporaryTables)
 				s.CreateQuery("delete from Party").ExecuteUpdate();
@@ -1240,7 +1239,7 @@ public virtual void OneToManyCollectionOptimisticLockingWithUpdate()
 				s.Delete(partyOrig);
 				s.Delete(newParty);
 			}
-
+			c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
 			s.Delete(c);
 			Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
 			Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));