NHibernate: How to test a many-to-one relationship is lazy?

Question

I've got a simple many-to-one relationship (an Order has a Customer who placed it). Here's the except from my Order mapping:

<many-to-one name="Customer" column="FK_CUSTOMERS" class="MyApp.Customer, MyApp" 
not-null="true" lazy="proxy" cascade="none" />

Yet the following does not pass:

configuration.GetClassMapping(typeof(Order))
  .ReferenceablePropertyIterator.FirstOrDefault(p=>p.Name=="Customer")
  .IsLazy
  .ShouldBeTrue();

What gives?

Answer 1

I was looking at the source and it seems NH treats IsLazy kind of weird. Here was the last change on 2010-01-26

get
            {
-               if (propertyValue is ToOne)
-               {
-                   // both many-to-one and one-to-one are represented as a
-                   // Property.  EntityPersister is relying on this value to
-                   // determine "lazy fetch groups" in terms of field-level
-                   // interception.  So we need to make sure that we return
-                   // true here for the case of many-to-one and one-to-one
-                   // with lazy="no-proxy"
-                   //
-                   // * impl note - lazy="no-proxy" currently forces both
-                   // lazy and unwrap to be set to true.  The other case we
-                   // are extremely interested in here is that of lazy="proxy"
-                   // where lazy is set to true, but unwrap is set to false.
-                   // thus we use both here under the assumption that this
-                   // return is really only ever used during persister
-                   // construction to determine the lazy property/field fetch
-                   // groupings.  If that assertion changes then this check
-                   // needs to change as well.  Partially, this is an issue with
-                   // the overloading of the term "lazy" here...
-                   ToOne toOneValue = (ToOne)propertyValue;
-                   return toOneValue.IsLazy && toOneValue.UnwrapProxy;
-               }
+               // NH Specific: Hibernate doesn't make a distinction between
+               // lazy and no-proxy, but NHibernate does. While Hibernate tracks
+               // just whatever a property is lazy, we need to track lazy/no-proxy seperatedly.
+               
                return isLazy;
            }

So it depends on the version you are using, but it looks like 2009 versions only return true for this property if you mapped it as noproxy (ie. UnwrapProxy). What does this give you?

var to1 = configuration.GetClassMapping(typeof(Order))
  .ReferenceablePropertyIterator.FirstOrDefault(p=>p.Name=="Customer")
  .Value as NHibernate.Mapping.ToOne;

to1.IsLazy.ShouldBeTrue();
to1.UnwrapProxy.ShouldBeFalse();