Tests for proxy interface handling

Author: bahusoid

src/NHibernate.Test/Async/StaticProxyTest/InterfaceHandling/Fixture.cs

@@ -0,0 +1,169 @@
+//------------------------------------------------------------------------------
+// <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 NHibernate.Cfg;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.StaticProxyTest.InterfaceHandling
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class FixtureAsync : TestCaseMappingByCode
+	{
+		private Guid _id = Guid.NewGuid();
+
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+
+			#region Subclass hierarchy
+
+			mapper.Class<EntityClassProxy>(
+				rc =>
+				{
+					rc.Id(x => x.Id);
+					rc.Property(x => x.Name);
+				});
+
+			mapper.UnionSubclass<SubEntityInterfaceProxy>(
+				rc =>
+				{
+					rc.Proxy(typeof(ISubEntityProxy));
+
+					rc.Property(x => x.AnotherName);
+				});
+
+			mapper.UnionSubclass<AnotherSubEntityInterfaceProxy>(
+				rc =>
+				{
+					rc.Proxy(typeof(IAnotherSubEntityProxy));
+
+					rc.Property(x => x.AnotherName);
+				});
+
+			mapper.Class<EntityWithSuperClassInterfaceLookup>(
+				rc =>
+				{
+					rc.Id(x => x.Id);
+					rc.Property(x => x.Name);
+					rc.ManyToOne(x => x.EntityLookup, x => x.Class(typeof(EntityClassProxy)));
+				});
+
+			#endregion Subclass hierarchy
+
+			mapper.Class<EntitySimple>(
+				rc =>
+				{
+
+					rc.Id(x => x.Id);
+					rc.Property(x => x.Name);
+				});
+
+			mapper.Class<EntityExplicitInterface>(
+				rc =>
+				{
+
+					rc.Id(x => x.Id);
+					rc.Property(x => x.Name);
+				});
+
+			mapper.Class<EntityMultiInterfaces>(
+				rc =>
+				{
+
+					rc.Id(x => x.Id);
+					rc.Property(x => x.Name);
+				});
+
+			mapper.Class<EntityMixExplicitImplicitInterface>(
+				rc =>
+				{
+
+					rc.Id(x => x.Id);
+					rc.Property(x => x.Name);
+				});
+
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		[Test]
+		public async Task ProxyForBaseSubclassCanBeCreatedAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var entity = await (session.LoadAsync<EntityClassProxy>(_id));
+			}
+		}
+
+		[Test]
+		public async Task ProxyForBaseSubclassByInterfaceAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var entity = (IEntity) await (session.LoadAsync(typeof(EntityClassProxy), _id));
+				ThrowOnIdAccess(entity);
+			}
+		}
+
+		[Test]
+		public async Task ProxyForEntityImplicitInterfaceAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var entity = (IEntity) await (session.LoadAsync<EntitySimple>(_id));
+				ThrowOnIdAccess(entity);
+				ThrowOnNameAccess(entity);
+
+				var multiInterface = await (session.LoadAsync<EntityMultiInterfaces>(_id));
+				ThrowOnIdAccess(multiInterface);
+				ThrowOnIdAccessSecond(multiInterface);
+			}
+		}
+
+		[Test]
+		public async Task ProxyForEntityInitializeOnExplicitInterfaceAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var entity = await (session.LoadAsync<EntityExplicitInterface>(_id));
+				ThrowOnIdAccess(entity);
+			}
+		}
+
+		[Test]
+		public async Task ProxyForEntityWithMixedImplicitExplicitInterfacesAreHandledCorrectlyAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var entity = await (session.LoadAsync<EntityMixExplicitImplicitInterface>(_id));
+				ThrowOnIdAccessSecond(entity);
+				ThrowOnIdAccess(entity);
+			}
+		}
+
+		private void ThrowOnNameAccess(IEntity entity)
+		{
+			Assert.That(() => entity.Name, Throws.TypeOf<ObjectNotFoundException>(), "Non Id interface access should lead to proxy initialization");
+		}
+
+		private void ThrowOnIdAccess(IEntity entity)
+		{
+			Assert.That(() => entity.Id, Throws.TypeOf<ObjectNotFoundException>(), "IEntity.Id access should lead to proxy initialization");
+		}
+
+		private void ThrowOnIdAccessSecond(IEntityId entity)
+		{
+			Assert.That(() => entity.Id, Throws.TypeOf<ObjectNotFoundException>(), "IEntityId.Id access should lead to proxy initialization");
+		}
+	}
+}

src/NHibernate.Test/StaticProxyTest/InterfaceHandling/BaseInterfaces.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace NHibernate.Test.StaticProxyTest.InterfaceHandling
+{
+	public interface IEntity
+	{
+		Guid Id { get; set; }
+
+		string Name { get; set; }
+	}
+	
+	public interface IEntityId
+	{
+		Guid Id { get; set; }
+	}
+}

src/NHibernate.Test/StaticProxyTest/InterfaceHandling/Entities.cs

@@ -0,0 +1,71 @@
+using System;
+
+namespace NHibernate.Test.StaticProxyTest.InterfaceHandling
+{
+	public class EntitySimple : IEntity
+	{
+		public virtual Guid Id { get; set; }
+
+		public virtual string Name { get; set; }
+	}
+
+	public class EntityMultiInterfaces : IEntity, IEntityId
+	{
+		public virtual Guid Id { get; set; }
+
+		public virtual string Name { get; set; }
+	}
+
+	public class EntityExplicitInterface : IEntity
+	{
+		private Guid id;
+		private string name;
+
+		public virtual Guid Id { get; set; }
+
+		public virtual string Name { get; set; }
+
+		Guid IEntity.Id
+		{
+			get => id;
+			set => id = value;
+		}
+
+		string IEntity.Name
+		{
+			get => name;
+			set => name = value;
+		}
+	}
+
+	public class EntityMixExplicitImplicitInterface : IEntity, IEntityId
+	{
+		private Guid id;
+		private string name;
+
+		public virtual Guid Id { get; set; }
+
+		public virtual string Name { get; set; }
+
+		Guid IEntity.Id
+		{
+			get => id;
+			set => id = value;
+		}
+
+		string IEntity.Name
+		{
+			get => name;
+			set => name = value;
+		}
+	}
+
+	public class EntityWithSuperClassInterfaceLookup
+	{
+		public virtual Guid Id { get; set; }
+
+		public virtual string Name { get; set; }
+
+		public virtual IEntity EntityLookup { get; set; }
+	}
+}