Merge branch NH-3432, containing backported fixes for dynamic proxy issues NH-3132, NH-2819, NH-2726, NH-3244 and NH-3058.

Author: oskarb

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/GenericMethodShouldBeProxied.cs

@@ -1,48 +1,62 @@
-using System.Collections.Generic;
 using NHibernate.Proxy.DynamicProxy;
 using NUnit.Framework;
 using SharpTestsEx;
 
 namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
 {
+	[TestFixture]
 	public class GenericMethodShouldBeProxied
 	{
-		public class MyClass
+		[Test]
+		public void CanProxyBasicGenericMethod()
 		{
-			public virtual object Method<T>()
-			{
-				if(typeof(T) == typeof(int))
-				{
-					return 5;
-				}
-				if (typeof(T) == typeof(string))
-				{
-					return "blha";
-				}
-				return default(T);
-			}
-
-			public virtual TRequestedType As<TRequestedType>() where TRequestedType : MyClass
-			{
-				return this as TRequestedType;
-			}
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
+			c.BasicGenericMethod<int>().Should().Be(5);
+			c.BasicGenericMethod<string>().Should().Be("blha");
 		}
 
 		[Test]
-		public void ProxyOfAGenericMethod()
+		public void CanProxyMethodWithGenericBaseClassConstraint()
 		{
 			var factory = new ProxyFactory();
 			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
-			c.Method<int>().Should().Be(5);
-			c.Method<string>().Should().Be("blha");
+			c.MethodWithGenericBaseClassConstraint<MyGenericClass<int>, int>().Should().Be(typeof(MyGenericClass<int>));
 		}
 
 		[Test]
-		public void ProxyOfSelfCastingMethod()
+		public void CanProxySelfCastingMethod()
 		{
 			var factory = new ProxyFactory();
 			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
 			c.As<MyClass>().Should().Not.Be.Null();
 		}
+
+		[Test]
+		public void CanProxyMethodWithDefaultConstructorConstraint()
+		{
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
+			c.MethodWithConstructorConstraint<MyClass>().Should().Not.Be.Null();
+		}
+
+		[Test]
+		public void CanProxyGenericMethodWithInterfaceConstraint()
+		{
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
+			c.MethodWithInterfaceConstraint<IMyInterface>().Should().Be(typeof(IMyInterface));
+		}
+
+		[Test]
+		public void CanProxyGenericMethodWithReferenceTypeAndInterfaceConstraint()
+		{
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyDerivedClass()), null);
+			c.MethodWithReferenceTypeAndInterfaceConstraint<MyDerivedClass>().Should().Not.Be.Null();
+		}
+
+		class MyDerivedClass : MyClass, IMyInterface
+		{ }
 	}
 }

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/IMyGenericInterface.cs

@@ -0,0 +1,6 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public interface IMyGenericInterface<TId>
+	{
+	}
+}

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/IMyInterface.cs

@@ -0,0 +1,6 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public interface IMyInterface
+	{
+	}
+}

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/MyClass.cs

@@ -0,0 +1,41 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public class MyClass
+	{
+		public virtual object BasicGenericMethod<T>()
+		{
+			if (typeof(T) == typeof(int))
+				return 5;
+
+			if (typeof(T) == typeof(string))
+				return "blha";
+
+			return default(T);
+		}
+
+		public virtual object MethodWithGenericBaseClassConstraint<T, TY>() where T : MyGenericClass<TY>
+		{
+			return typeof(T);
+		}
+
+		public virtual object MethodWithInterfaceConstraint<T>() where T : IMyInterface
+		{
+			return typeof(T);
+		}
+
+		public virtual TRequestedType As<TRequestedType>() where TRequestedType : MyClass
+		{
+			return this as TRequestedType;
+		}
+
+		public virtual TRequestedType MethodWithConstructorConstraint<TRequestedType>() where TRequestedType : new()
+		{
+			return new TRequestedType();
+		}
+
+		public virtual TRequestedType MethodWithReferenceTypeAndInterfaceConstraint<TRequestedType>() where TRequestedType : class, IMyInterface
+		{
+			return this as TRequestedType;
+		}
+	}
+}

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/MyGenericClass.cs

@@ -0,0 +1,15 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public class MyGenericClass<TId> : IMyGenericInterface<TId>
+	{
+		public virtual TRequestedType As<TRequestedType>() where TRequestedType : MyGenericClass<TId>
+		{
+			return this as TRequestedType;
+		}
+
+		public virtual TRequestedType AsInterface<TRequestedType>() where TRequestedType : class, IMyGenericInterface<TId>
+		{
+			return this as TRequestedType;
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/NH3058/DomainClass.cs

@@ -0,0 +1,14 @@
+namespace NHibernate.Test.NHSpecificTest.NH3058
+{
+	public class DomainClass
+	{
+		public virtual int Id { get; set; }
+		public virtual string Name { get; set; }
+		public virtual string ALotOfText { get; set; }
+
+		public virtual string LoadLazyProperty()
+		{
+			return ALotOfText;
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/NH3058/Mappings.hbm.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHibernate.Test"
+                   namespace="NHibernate.Test.NHSpecificTest.NH3058">
+  <class name="DomainClass">
+    <id name="Id">
+      <generator class="assigned" />
+    </id>
+    <property name="Name" />
+    <property name="ALotOfText" lazy="true" />
+  </class>
+</hibernate-mapping>

src/NHibernate.Test/NHSpecificTest/NH3058/SampleTest.cs

@@ -0,0 +1,83 @@
+using NHibernate.Context;
+using NHibernate.Engine;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.NH3058
+{
+	[TestFixture]
+	public class SampleTest : BugTestCase
+	{
+		public static ISessionFactoryImplementor AmbientSfi { get; private set; }
+
+		protected override void BuildSessionFactory()
+		{
+			base.BuildSessionFactory();
+
+			AmbientSfi = Sfi;
+		}
+
+		protected override void Configure(Cfg.Configuration configuration)
+		{
+			base.Configure(configuration);
+
+			configuration.Properties.Add("current_session_context_class", "thread_static");
+		}
+
+		protected override ISession OpenSession()
+		{
+			var session = base.OpenSession();
+
+			CurrentSessionContext.Bind(session);
+
+			return session;
+		}
+
+		protected override void OnSetUp()
+		{
+			base.OnSetUp();
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var book = new DomainClass
+				{
+					Name = "Some name",
+					ALotOfText = "Some text",
+					Id = 1
+				};
+
+				s.Persist(book);
+				tx.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			base.OnTearDown();
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				Assert.That(s.CreateSQLQuery("delete from DomainClass").ExecuteUpdate(), Is.EqualTo(1));
+				tx.Commit();
+			}
+		}
+
+		[Test]
+		public void MethodShouldLoadLazyProperty()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var book = s.Load<DomainClass>(1);
+				
+				Assert.False(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"));
+
+				string value = book.LoadLazyProperty();
+
+				Assert.That(value, Is.EqualTo("Some text"));
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+
+				tx.Commit();
+			}
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/NH3132/Fixture.cs

@@ -0,0 +1,111 @@
+using System.Collections;
+using NHibernate.Criterion;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.NH3132
+{
+	[TestFixture]
+	public class Fixture : BugTestCase
+	{
+		/// <summary>
+		/// push some data into the database
+		/// Really functions as a save test also 
+		/// </summary>
+		protected override void OnSetUp()
+		{
+			base.OnSetUp();
+
+			using (var session = OpenSession())
+			{
+				using (var tran = session.BeginTransaction())
+				{
+					Product product = new Product();
+					product.Name = "First";
+					product.Lazy = "Lazy";
+					
+					session.Save(product);
+
+					tran.Commit();
+				}
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			base.OnTearDown();
+
+			using (var session = OpenSession())
+			using (var tran = session.BeginTransaction())
+			{
+				session.Delete("from Product");
+				tran.Commit();
+			}
+		}
+
+		[Test]
+		public void Query_returns_correct_name()
+		{
+			using (var session = OpenSession())
+			{
+				Product product = session.CreateCriteria(typeof (Product))
+					.Add(Restrictions.Eq("Name", "First"))
+					.UniqueResult<Product>();
+
+				Assert.IsNotNull(product);
+				Assert.AreEqual("First", product.Name);
+			}
+		}
+
+		[Test]
+		public void Correct_value_gets_saved()
+		{
+			using (var session = OpenSession())
+			{
+				var product = session.CreateCriteria(typeof(Product))
+					.Add(Restrictions.Eq("Name", "First"))
+					.UniqueResult<Product>();
+
+				Assert.That(product, Is.Not.Null);
+				product.Name = "Changed";
+
+				session.Flush();
+				
+				session.Clear();
+
+				var product1 = session.CreateCriteria(typeof(Product))
+					.Add(Restrictions.Eq("Name", "Changed"))
+					.UniqueResult<Product>();
+
+				Assert.That(product1, Is.Not.Null);
+				Assert.That(product1.Name, Is.EqualTo("Changed"));
+			}
+		}
+
+		[Test]
+		public void Correct_value_gets_saved_with_lazy()
+		{
+			using (var session = OpenSession())
+			{
+				var product = session.CreateCriteria(typeof(Product))
+					.Add(Restrictions.Eq("Name", "First"))
+					.UniqueResult<Product>();
+
+				Assert.That(product, Is.Not.Null);
+				product.Name = "Changed";
+				product.Lazy = "LazyChanged";
+
+				session.Flush();
+				
+				session.Clear();
+
+				var product1 = session.CreateCriteria(typeof(Product))
+					.Add(Restrictions.Eq("Name", "Changed"))
+					.UniqueResult<Product>();
+
+				Assert.That(product1, Is.Not.Null);
+				Assert.That(product1.Name, Is.EqualTo("Changed"));
+				Assert.That(product1.Lazy, Is.EqualTo("LazyChanged"));
+			}
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/NH3132/Mappings.hbm.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHibernate.Test"
+                   namespace="NHibernate.Test.NHSpecificTest.NH3132">
+  <class name="Product" table="Products">
+    <id name="Id" type="Guid">
+      <generator class="guid" />
+    </id>
+    <property name="Name" access="field.camelcase-underscore"/>
+    <property name="Lazy" lazy="true"/>
+  </class>
+</hibernate-mapping>