Added validation for many-to-many relationships with Inverse specified on both sides.

Author: jagregory

src/FluentNHibernate.Specs/PersistenceModel/PersistenceModelSpecs.Validation.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using FluentNHibernate.Mapping;
 using FluentNHibernate.Visitors;
 using Machine.Specifications;
@@ -51,6 +52,43 @@ public class when_the_persistence_model_is_told_to_build_the_mappings_with_a_cla
             exception.Message.ShouldEqual("The entity 'Target' doesn't have an Id mapped. Use the Id method to map your identity property. For example: Id(x => x.Id).");
     }
 
+    public class when_the_persistence_model_is_told_to_build_the_mappings_with_a_many_to_many_relationship_with_inverse_specified_on_both_sides : PersistenceModelValidationSpec
+    {
+        Establish context = () =>
+        {
+            var left = new ClassMap<Left>();
+            left.Id(x => x.Id);
+            left.HasManyToMany(x => x.Rights)
+                .Inverse();
+            var right = new ClassMap<Right>();
+            right.Id(x => x.Id);
+            right.HasManyToMany(x => x.Lefts)
+                .Inverse();
+
+            model = new FluentNHibernate.PersistenceModel();
+            model.Add(left);
+            model.Add(right);
+        };
+
+        Because of = () =>
+            exception = Catch.Exception(() => model.BuildMappings());
+
+        It should_throw_a_validation_exception = () =>
+        {
+            exception.ShouldNotBeNull();
+            exception.ShouldBeOfType<ValidationException>();
+        };
+
+        It should_indicate_which_entity_has_the_invalid_many_to_many = () =>
+            exception.As<ValidationException>().RelatedEntity.ShouldEqual(typeof(Left));
+
+        It should_explain_how_to_correct_the_error = () =>
+            exception.As<ValidationException>().Resolution.ShouldEqual("Remove Inverse from one side of the relationship");
+
+        It should_provide_a_sufficently_detailed_message_in_the_exception = () =>
+            exception.Message.ShouldEqual("The relationship Left.Rights to Right.Lefts has Inverse specified on both sides. Remove Inverse from one side of the relationship.");
+    }
+
     public class when_the_persistence_model_with_validation_disabled_is_told_to_build_the_mappings_with_a_class_mapping_that_doesnt_have_an_id : PersistenceModelValidationSpec
     {
         Establish context = () =>
@@ -76,5 +114,17 @@ protected class Target
         {
             public int Id { get; set; }
         }
+
+        protected class Left
+        {
+            public int Id { get; set; }
+            public IList<Right> Rights { get; set; }
+        }
+
+        protected class Right
+        {
+            public int Id { get; set; }
+            public IList<Left> Lefts { get; set; }
+        }
     }
 }

src/FluentNHibernate/Visitors/ValidationVisitor.cs

@@ -1,4 +1,5 @@
 using FluentNHibernate.MappingModel.ClassBased;
+using FluentNHibernate.MappingModel.Collections;
 
 namespace FluentNHibernate.Visitors
 {
@@ -23,6 +24,22 @@ public override void ProcessClass(ClassMapping classMapping)
                 );
         }
 
+        protected override void ProcessCollection(ICollectionMapping mapping)
+        {
+            if (!Enabled) return;
+
+            var otherSide = mapping.OtherSide as ICollectionMapping;
+
+            if (otherSide == null) return;
+            if (mapping.Inverse && otherSide.Inverse)
+            {
+                throw new ValidationException(
+                    string.Format("The relationship {0}.{1} to {2}.{3} has Inverse specified on both sides.", mapping.ContainingEntityType.Name, mapping.Name, otherSide.ContainingEntityType.Name, otherSide.Name),
+                    "Remove Inverse from one side of the relationship",
+                    mapping.ContainingEntityType);
+            }
+        }
+
         /// <summary>
         /// Gets or sets whether validation is performed.
         /// </summary>