can't find a way to write a proper test - need to test the applicability of a convention to particular IUserType

Author: chester89

src/FluentNHibernate.Testing/AutoMapping/Apm/AutoPersistenceModelTests.Conventions.cs

@@ -2,7 +2,10 @@
 using FluentNHibernate.Automapping.TestFixtures;
 using FluentNHibernate.Automapping.TestFixtures.ComponentTypes;
 using FluentNHibernate.Automapping.TestFixtures.CustomTypes;
+using FluentNHibernate.Conventions;
+using FluentNHibernate.Conventions.AcceptanceCriteria;
 using FluentNHibernate.Conventions.Helpers;
+using FluentNHibernate.Conventions.Inspections;
 using FluentNHibernate.Testing.Automapping;
 using NUnit.Framework;
 
@@ -79,6 +82,12 @@ public void TestAutoMapClassAppliesConventions()
                 .Element("class").HasAttribute("table", "test");
         }
 
+        [Test]
+        public void UserTypeConventionAppliesToNullableType()
+        {
+            new ValueTypeConvention().Accept(new ConcreteAcceptanceCriteria<IPropertyInspector>());
+        }
+
         [Test]
         public void TypeConventionShouldForcePropertyToBeMapped()
         {

src/FluentNHibernate.Testing/AutoMapping/TestFixtures.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Data;
 using System.Drawing;
+using System.IO;
 using FluentNHibernate.Automapping.TestFixtures.ComponentTypes;
 using FluentNHibernate.Automapping.TestFixtures.CustomCompositeTypes;
 using FluentNHibernate.Automapping.TestFixtures.CustomTypes;
@@ -155,6 +156,62 @@ public class ClassWithUserType
         public Custom Custom { get; set; }
     }
 
+    public class ContainingUserValueType
+    {
+        public int Id { get; set; }
+        public UserValueType UserValueType { get; set; }
+    }
+
+    public struct UserValueType: IUserType
+    {
+        public string AddressLine1 { get; set; }
+        public string AddressLine2 { get; set; }
+
+        public bool Equals(object x, object y)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int GetHashCode(object x)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object NullSafeGet(IDataReader rs, string[] names, object owner)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void NullSafeSet(IDbCommand cmd, object value, int index)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object DeepCopy(object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object Replace(object original, object target, object owner)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object Assemble(object cached, object owner)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object Disassemble(object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public SqlType[] SqlTypes { get; private set; }
+        public Type ReturnedType { get { return typeof(Double); } }
+        public bool IsMutable { get; private set; }
+    }
+
     public class ClassWithCompositeUserType
     {
         public int Id { get; set; }
@@ -222,6 +279,16 @@ public class DoubleString
     public class CustomTypeConvention : UserTypeConvention<CustomUserType>
     {}
 
+    public class ValueTypeConvention: UserTypeConvention<UserValueType>
+    {
+        public override void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
+        {
+            base.Accept(criteria);
+            criteria.Expect(x => x.Length > 15);
+        }
+
+    }
+
     public class CustomCompositeTypeConvention : IUserTypeConvention
     {
         public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)

src/FluentNHibernate/Conventions/IVersionConvention.cs

@@ -5,7 +5,7 @@
 namespace FluentNHibernate.Conventions
 {
     /// <summary>
-    /// Version convention, implement this interface to apply changes to vesion mappings.
+    /// Version convention, implement this interface to apply changes to version mappings.
     /// </summary>
     public interface IVersionConvention : IConvention<IVersionInspector, IVersionInstance>
     { }

src/FluentNHibernate/Conventions/UserTypeConvention.cs

@@ -19,12 +19,12 @@ public virtual void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
         {
             var userType = Activator.CreateInstance<TUserType>();
             var returnedType = userType.ReturnedType;
-            if (returnedType.IsValueType)
-            {
-                var nullableReturnedType = typeof(Nullable<>).MakeGenericType(returnedType);
-                criteria.Expect(x => x.Type == returnedType || x.Type == nullableReturnedType);
-            }
-            else
+            //if (returnedType.IsValueType)
+            //{
+            //    var nullableReturnedType = typeof(Nullable<>).MakeGenericType(returnedType);
+            //    criteria.Expect(x => x.Type == returnedType || x.Type == nullableReturnedType);
+            //}
+            //else
                 criteria.Expect(x => x.Type == returnedType);
         }