NH-3693 - case sensitive resolver with fallback to case insensitive.

Author: fredericDelaporte

src/NHibernate.Test/TransformTests/AliasToBeanResultTransformerFixture.cs

@@ -1,6 +1,7 @@
 using System.Collections;
-using System.Collections.Generic;
+using System.Reflection;
 using NHibernate.Transform;
+using NHibernate.Util;
 using NUnit.Framework;
 
 namespace NHibernate.Test.TransformTests
@@ -11,7 +12,7 @@ public class AliasToBeanResultTransformerFixture : TestCase
 		public class WithOutPublicParameterLessCtor
 		{
 			private string something;
-			protected WithOutPublicParameterLessCtor() {}
+			protected WithOutPublicParameterLessCtor() { }
 
 			public WithOutPublicParameterLessCtor(string something)
 			{
@@ -48,8 +49,10 @@ public class PublicPropertiesSimpleDTO
 
 		public class PrivateFieldsSimpleDTO
 		{
+#pragma warning disable CS0649
 			private object id;
 			private string name;
+#pragma warning restore CS0649
 
 			public object Id { get { return id; } }
 			public string Name { get { return name; } }
@@ -67,221 +70,227 @@ public class PublicInheritedPropertiesSimpleDTO : BasePublicPropsSimpleDTO
 
 		public class BasePrivateFieldSimpleDTO
 		{
+#pragma warning disable CS0649
 			private object id;
+#pragma warning restore CS0649
 			public object Id { get { return id; } }
 		}
 
 		public class PrivateInheritedFieldsSimpleDTO : BasePrivateFieldSimpleDTO
 		{
+#pragma warning disable CS0649
 			private string name;
+#pragma warning restore CS0649
 			public string Name { get { return name; } }
 		}
 
+		public class PropertiesInsensitivelyDuplicated
+		{
+			public object Id { get; set; }
+			public string NaMe { get; set; }
+			public string NamE { get; set; }
+		}
+
+		public class BasePrivateFieldSimpleDTO2
+		{
+#pragma warning disable CS0649
+			private object _id;
+#pragma warning restore CS0649
+			public object iD => _id;
+		}
+
+		public class PrivateInheritedFieldsSimpleDTO2 : BasePrivateFieldSimpleDTO2
+		{
+#pragma warning disable CS0649
+			private string namE;
+#pragma warning restore CS0649
+			public string Name { get { return namE; } }
+		}
+
+		public class NewPropertiesSimpleDTO : PrivateInheritedFieldsSimpleDTO2
+		{
+			public new string Name { get; set; }
+			internal string NaMe { get; set; }
+
+			public object Id { get; set; }
+		}
+
 		#region Overrides of TestCase
 
 		protected override IList Mappings
 		{
-			get { return new[] {"TransformTests.Simple.hbm.xml"}; }
+			get { return new[] { "TransformTests.Simple.hbm.xml" }; }
 		}
 
 		protected override string MappingsAssembly
 		{
 			get { return "NHibernate.Test"; }
 		}
 
-		#endregion
-
-		[Test]
-		public void WorkWithOutPublicParameterLessCtor()
+		protected override void OnSetUp()
 		{
-			try
+			using (var s = OpenSession())
 			{
-				Setup();
-
-				using (ISession s = OpenSession())
+				using (s.BeginTransaction())
 				{
-					IList<WithOutPublicParameterLessCtor> l =
-						s.CreateSQLQuery("select s.Name as something from Simple s").SetResultTransformer(
-							Transformers.AliasToBean<WithOutPublicParameterLessCtor>()).List<WithOutPublicParameterLessCtor>();
-					Assert.That(l.Count, Is.EqualTo(2));
-					Assert.That(l, Has.All.Not.Null);
+					s.Save(new Simple { Name = "Name1" });
+					s.Save(new Simple { Name = "Name2" });
+					s.Transaction.Commit();
 				}
 			}
-			finally
-			{
-				Cleanup();	
-			}
 		}
 
-		[Test]
-		public void ToPublicProperties_WithoutAnyProjections()
+		protected override void OnTearDown()
 		{
-			try
+			using (var s = OpenSession())
 			{
-				Setup();
-
-				using (ISession s = OpenSession())
+				using (s.BeginTransaction())
 				{
-					var transformer = Transformers.AliasToBean<PublicPropertiesSimpleDTO>();
-					IList<PublicPropertiesSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
-						.SetResultTransformer(transformer)
-						.List<PublicPropertiesSimpleDTO>();
-					Assert.That(l.Count, Is.EqualTo(2));
-					Assert.That(l, Has.All.Not.Null);
+					s.Delete("from Simple");
+					s.Transaction.Commit();
 				}
 			}
-			finally
-			{
-				Cleanup();
-			}			
 		}
 
+		#endregion
+
 		[Test]
-		public void ToPrivateFields_WithoutAnyProjections()
+		public void WorkWithOutPublicParameterLessCtor()
 		{
-			try
-			{
-				Setup();
+			AssertCardinalityAndSomething<WithOutPublicParameterLessCtor>();
+		}
 
-				using (ISession s = OpenSession())
-				{
-					var transformer = Transformers.AliasToBean<PrivateFieldsSimpleDTO>();
-					IList<PrivateFieldsSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
-						.SetResultTransformer(transformer)
-						.List<PrivateFieldsSimpleDTO>();
-					Assert.That(l.Count, Is.EqualTo(2));
-					Assert.That(l, Has.All.Not.Null);
-				}
-			}
-			finally
-			{
-				Cleanup();
-			}
+		[Test]
+		public void ToPublicProperties_WithoutAnyProjections()
+		{
+			AssertCardinalityNameAndId<PublicPropertiesSimpleDTO>();
 		}
 
 		[Test]
-		public void ToInheritedPublicProperties_WithoutProjections()
+		public void ToPrivateFields_WithoutAnyProjections()
 		{
-			try
-			{
-				Setup();
+			AssertCardinalityNameAndId<PrivateFieldsSimpleDTO>();
+		}
 
-				using (ISession s = OpenSession())
-				{
-					var transformer = Transformers.AliasToBean<PublicInheritedPropertiesSimpleDTO>();
-					IList<PublicInheritedPropertiesSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
-						.SetResultTransformer(transformer)
-						.List<PublicInheritedPropertiesSimpleDTO>();
-					Assert.That(l.Count, Is.EqualTo(2));
-					Assert.That(l, Has.All.Not.Null);
-				}
-			}
-			finally
-			{
-				Cleanup();
-			}
+		[Test]
+		public void ToInheritedPublicProperties_WithoutProjections()
+		{
+			AssertCardinalityNameAndId<PublicInheritedPropertiesSimpleDTO>();
 		}
 
 		[Test]
 		public void ToInheritedPrivateFields_WithoutProjections()
 		{
-			try
-			{
-				Setup();
-
-				using (ISession s = OpenSession())
-				{
-					var transformer = Transformers.AliasToBean<PrivateInheritedFieldsSimpleDTO>();
-					IList<PrivateInheritedFieldsSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
-						.SetResultTransformer(transformer)
-						.List<PrivateInheritedFieldsSimpleDTO>();
-					Assert.That(l.Count, Is.EqualTo(2));
-					Assert.That(l, Has.All.Not.Null);
-					Assert.That(l, Has.All.Property("Id").Not.Null);
-				}
-			}
-			finally
-			{
-				Cleanup();
-			}
+			AssertCardinalityNameAndId<PrivateInheritedFieldsSimpleDTO>();
 		}
 
 		[Test]
-		public void WorkWithPublicParameterLessCtor()
+		public void WorkWithPublicParameterLessCtor_Fields()
 		{
-			try
-			{
-				Setup();
-
-				var queryString = "select s.Name as something from Simple s";
-				AssertAreWorking(queryString); // working for field access
+			AssertCardinalityAndSomething<PublicParameterLessCtor>();
+		}
 
-				queryString = "select s.Name as Something from Simple s";
-				AssertAreWorking(queryString); // working for property access
-			}
-			finally
-			{
-				Cleanup();
-			}
+		[Test]
+		public void WorkWithPublicParameterLessCtor_Properties()
+		{
+			AssertCardinalityAndSomething<PublicParameterLessCtor>("select s.Name as Something from Simple s");
 		}
 
 		[Test]
 		public void WorksWithStruct()
 		{
-			try
-			{
-				Setup();
+			AssertCardinalityAndSomething<TestStruct>();
+		}
 
-				IList<TestStruct> result;
-				using (ISession s = OpenSession())
-				{
-					result = s.CreateSQLQuery("select s.Name as something from Simple s")
-						.SetResultTransformer(Transformers.AliasToBean<TestStruct>())
-						.List<TestStruct>();
-				}
-				Assert.AreEqual(2, result.Count);
-			}
-			finally
-			{
-				Cleanup();
-			}
+		[Test]
+		public void WorksWithNewProperty()
+		{
+			AssertCardinalityNameAndId<NewPropertiesSimpleDTO>();
 		}
 
-		private void AssertAreWorking(string queryString)
+		[Test]
+		public void WorksWithManyCandidates()
 		{
-			using (ISession s = OpenSession())
+			using (var s = OpenSession())
 			{
-				IList<PublicParameterLessCtor> l =
-					s.CreateSQLQuery(queryString).SetResultTransformer(
-						Transformers.AliasToBean<PublicParameterLessCtor>()).List<PublicParameterLessCtor>();
+				var transformer = Transformers.AliasToBean<NewPropertiesSimpleDTO>();
+				var l = s.CreateSQLQuery("select id as ID, Name as NamE from Simple")
+						.SetResultTransformer(transformer)
+						.List<NewPropertiesSimpleDTO>();
 				Assert.That(l.Count, Is.EqualTo(2));
 				Assert.That(l, Has.All.Not.Null);
+				Assert.That(l, Has.Some.Property("Name").EqualTo("Name1"));
+				Assert.That(l, Has.Some.Property("Name").EqualTo("Name2"));
+				Assert.That(l, Has.All.Property("Id").Not.Null);
+				Assert.That(l, Has.All.Property("iD").Null);
+				Assert.That(l, Has.All.Property("NaMe").Null);
 			}
 		}
 
-		private void Cleanup()
+		[Test]
+		public void ToPropertiesInsensitivelyDuplicated_WithoutAnyProjections()
 		{
-			using (ISession s = OpenSession())
+			using (var s = OpenSession())
 			{
-				using (s.BeginTransaction())
+				var transformer = Transformers.AliasToBean<PropertiesInsensitivelyDuplicated>();
+				Assert.Throws<AmbiguousMatchException>(() =>
 				{
-					s.Delete("from Simple");
-					s.Transaction.Commit();
-				}
+					s.CreateSQLQuery("select * from Simple")
+						.SetResultTransformer(transformer)
+						.List<PropertiesInsensitivelyDuplicated>();
+				});
 			}
 		}
 
-		private void Setup()
+		[Test]
+		public void Serialization()
 		{
-			using (ISession s = OpenSession())
+			AssertSerialization<PublicPropertiesSimpleDTO>();
+			AssertSerialization<PrivateFieldsSimpleDTO>();
+			AssertSerialization<PublicInheritedPropertiesSimpleDTO>();
+			AssertSerialization<PrivateInheritedFieldsSimpleDTO>();
+			AssertSerialization<NewPropertiesSimpleDTO>();
+		}
+
+		private void AssertCardinalityNameAndId<T>(IResultTransformer transformer = null)
+		{
+			using (var s = OpenSession())
 			{
-				using (s.BeginTransaction())
-				{
-					s.Save(new Simple {Name = "Name1"});
-					s.Save(new Simple {Name = "Name2"});
-					s.Transaction.Commit();
-				}
+				transformer = transformer ?? Transformers.AliasToBean<T>();
+				var l = s.CreateSQLQuery("select * from Simple")
+						.SetResultTransformer(transformer)
+						.List<T>();
+				var testClass = typeof(T).Name;
+				Assert.That(l.Count, Is.EqualTo(2), testClass);
+				Assert.That(l, Has.All.Not.Null, testClass);
+				Assert.That(l, Has.Some.Property("Name").EqualTo("Name1"), testClass);
+				Assert.That(l, Has.Some.Property("Name").EqualTo("Name2"), testClass);
+				Assert.That(l, Has.All.Property("Id").Not.Null, testClass);
 			}
 		}
+
+		private void AssertCardinalityAndSomething<T>(string queryString = "select s.Name as something from Simple s")
+		{
+			using (var s = OpenSession())
+			{
+				var transformer = Transformers.AliasToBean<T>();
+				var l = s.CreateSQLQuery(queryString)
+						.SetResultTransformer(transformer)
+						.List<T>();
+				var testClass = typeof(T).Name;
+				Assert.That(l.Count, Is.EqualTo(2), testClass);
+				Assert.That(l, Has.All.Not.Null, testClass);
+				Assert.That(l, Has.Some.Property("Something").EqualTo("Name1"), testClass);
+				Assert.That(l, Has.Some.Property("Something").EqualTo("Name2"), testClass);
+			}
+		}
+
+		private void AssertSerialization<T>()
+		{
+			var transformer = Transformers.AliasToBean<T>();
+			var bytes = SerializationHelper.Serialize(transformer);
+			transformer = (IResultTransformer)SerializationHelper.Deserialize(bytes);
+			AssertCardinalityNameAndId<T>(transformer: transformer);
+		}
 	}
 }