Merge remote-tracking branch 'RyanHauert/TestingImprovements'

Author: jagregory

src/FluentNHibernate.Testing/Testing/PersistenceSpecificationTester.cs

@@ -145,6 +145,16 @@ public void should_not_be_equal_without_the_equality_comparer()
                 _spec.CheckList(x => x.AllKittens, _cat.AllKittens).VerifyTheMappings());
         }
 
+        [Test]
+        public void Comparing_objects_in_two_lists_should_use_the_specified_comparisons()
+        {
+            _spec.CheckList(x => x.AllKittens, _cat.AllKittens, kitten => kitten.Id).VerifyTheMappings();
+
+            // Should fail because the names don't match.
+            Assert.Throws<ApplicationException>(() => _spec.CheckList(x => x.AllKittens, _cat.AllKittens, kitten => kitten.Id, kitten => kitten.Name)
+                .VerifyTheMappings());
+        }
+
         [Test]
         public void Can_test_enumerable()
         {
@@ -168,6 +178,16 @@ public void VerifyTheMappings_returns_instance()
 			var cat = _spec.CheckProperty(x => x.FirstKitten, _cat.FirstKitten).VerifyTheMappings();
 			cat.ShouldNotBeNull();
     	}
+
+        [Test]
+        public void Comparing_reference_should_use_the_specified_property_comparisons()
+        {
+            _spec.CheckReference(cat => cat.FirstKitten, _cat.FirstKitten, x => x.Id).VerifyTheMappings();
+
+            // Should fail because the names don't match.
+            Assert.Throws<ApplicationException>(() => _spec.CheckReference(cat => cat.FirstKitten, _cat.FirstKitten, x => x.Id, x => x.Name)
+                .VerifyTheMappings());
+        }
     }
 
     [TestFixture]

src/FluentNHibernate/Testing/PersistenceSpecificationExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using FluentNHibernate.Testing.Values;
 using FluentNHibernate.Utils;
@@ -81,6 +82,19 @@ public static PersistenceSpecification<T> CheckReference<T>(this PersistenceSpec
             return spec.RegisterCheckedProperty(new ReferenceProperty<T, object>(property, propertyValue), propertyComparer);
         }
 
+        public static PersistenceSpecification<T> CheckReference<T, TReference>(this PersistenceSpecification<T> spec,
+                                                                   Expression<Func<T, object>> expression,
+                                                                   TReference propertyValue,
+                                                                   params Func<TReference, object>[] propertiesToCompare)
+        {
+            // Because of the params keyword, the compiler will select this overload
+            // instead of the one above, even when no funcs are supplied in the method call.
+            if (propertiesToCompare == null || propertiesToCompare.Length == 0)
+                return spec.CheckReference(expression, propertyValue, (IEqualityComparer)null);
+
+            return spec.CheckReference(expression, propertyValue, new FuncEqualityComparer<TReference>(propertiesToCompare));
+        }
+
         public static PersistenceSpecification<T> CheckReference<T, TProperty>(this PersistenceSpecification<T> spec,
                                                                                 Expression<Func<T, TProperty>> expression,
                                                                                 TProperty propertyValue,
@@ -121,6 +135,19 @@ public static PersistenceSpecification<T> CheckList<T, TListElement>(this Persis
             return spec.RegisterCheckedProperty(new ReferenceList<T, TListElement>(property, propertyValue), elementComparer);
         }
 
+        public static PersistenceSpecification<T> CheckList<T, TListElement>(this PersistenceSpecification<T> spec,
+                                                                            Expression<Func<T, IEnumerable<TListElement>>> expression,
+                                                                            IEnumerable<TListElement> propertyValue,
+                                                                            params Func<TListElement, object>[] propertiesToCompare)
+        {
+            // Because of the params keyword, the compiler can select this overload
+            // instead of the one above, even when no funcs are supplied in the method call.
+            if (propertiesToCompare == null || propertiesToCompare.Length == 0)
+                return spec.CheckList(expression, propertyValue, (IEqualityComparer)null);
+
+            return spec.CheckList(expression, propertyValue, new FuncEqualityComparer<TListElement>(propertiesToCompare));
+        }
+
         public static PersistenceSpecification<T> CheckList<T, TListElement>(this PersistenceSpecification<T> spec,
                                                                               Expression<Func<T, IEnumerable<TListElement>>> expression,
                                                                               IEnumerable<TListElement> propertyValue,
@@ -254,5 +281,25 @@ public static PersistenceSpecification<T> CheckEnumerable<T, TItem>(this Persist
         {
             return spec.CheckList(expression, itemsToAdd, addAction);
         }
+
+        private class FuncEqualityComparer<T> : EqualityComparer<T>
+        {
+            readonly IEnumerable<Func<T, object>> comparisons;
+
+            public FuncEqualityComparer(IEnumerable<Func<T, object>> comparisons)
+            {
+                this.comparisons = comparisons;
+            }
+
+            public override bool Equals(T x, T y)
+            {
+                return comparisons.All(func => object.Equals(func(x), func(y)));
+            }
+
+            public override int GetHashCode(T obj)
+            {
+                throw new NotSupportedException();
+            }
+        }
     }
 }