Merge pull request #139 from CedricYao/master

Edits to the Persistence Specification class.

Author: jagregory

src/FluentNHibernate.Testing/FluentNHibernate.Testing.csproj

@@ -402,6 +402,7 @@
     <Compile Include="MappingModel\HibernateMappingTester.cs" />
     <Compile Include="MappingModel\MappingTestingExtensions.cs" />
     <Compile Include="Testing\Values\ListSpecs.cs" />
+    <Compile Include="Testing\Values\ReferenceBagSpec.cs" />
     <Compile Include="Testing\Values\ReferenceListSpecs.cs" />
     <Compile Include="Testing\Values\ReferencePropertySpecs.cs" />
     <Compile Include="Testing\Values\PropertySpecs.cs" />

src/FluentNHibernate.Testing/Testing/PersistenceSpecificationExtensionsSpecs.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using FluentNHibernate.Testing.Testing.Values;
 using FluentNHibernate.Testing.Values;
@@ -247,6 +248,36 @@ public void should_invoke_the_custom_setter()
         }
     }
 
+    [TestFixture]
+    public class when_a_unordered_bag_is_added :With_persistence_specification<ReferenceEntity>
+    {
+        OtherEntity entity1 = new OtherEntity();
+        OtherEntity entity2 = new OtherEntity();
+
+        public override void because()
+        {
+            sut.CheckBag(x => x.ReferenceList, new[] {entity1, entity2});
+        }
+
+        [Test]
+        public void should_add_a_reference_bag_check()
+        {
+            sut.AllProperties.FirstOrDefault().ShouldBeOfType(typeof(ReferenceBag<ReferenceEntity, OtherEntity>));
+        }
+
+        [Test]
+        public void should_add_only_one_check_to_the_specification()
+        {
+            sut.AllProperties.ShouldHaveCount(1);
+        }
+
+        [Test]
+        public void should_set_the_custom_equality_comparer()
+        {
+            sut.AllProperties.FirstOrDefault().EntityEqualityComparer.ShouldEqual(comparer);
+        }
+    }
+
     [TestFixture]
     public class When_a_checked_list_is_added : With_persistence_specification<ReferenceEntity>
     {

src/FluentNHibernate.Testing/Testing/Values/ReferenceBagSpec.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using FluentNHibernate.Testing.Values;
+using FluentNHibernate.Utils;
+using FluentNHibernate.Utils.Reflection;
+using NUnit.Framework;
+
+namespace FluentNHibernate.Testing.Testing.Values
+{
+    public class ReferenceBagSpec
+    {
+        public abstract class With_initialized_bag : Specification
+        {
+            protected Accessor property;
+            protected ListEntity target;
+            protected ReferenceBag<ListEntity, string> sut;
+
+            public override void establish_context()
+            {
+                property = ReflectionHelper.GetAccessor((Expression<Func<ListEntity, IEnumerable<string>>>)(x => x.GetterAndSetter));
+                target = new ListEntity();
+
+                sut = new ReferenceBag<ListEntity, string>(property, new[] { "foo", "bar", "baz" });
+            }
+        }
+
+        [TestFixture]
+        public class When_the_checked_bag_has_multiple_items : With_initialized_bag
+        {
+            public override void establish_context()
+            {
+                var baz = "baz";
+                property = ReflectionHelper.GetAccessor((Expression<Func<ListEntity, IEnumerable<string>>>)(x => x.GetterAndSetter));
+                target = new ListEntity();
+                sut = new ReferenceBag<ListEntity, string>(property, new[] {"foo", baz, baz, "bar"});
+                
+                target.GetterAndSetter = new[] {baz, baz, "bar", "foo"};
+            }
+
+            public override void because()
+            {
+                sut.CheckValue(target);
+            }
+
+            [Test]
+            public void should_succeed()
+            {
+                thrown_exception.ShouldBeNull();
+            }
+        }
+
+        [TestFixture]
+        public class when_checked_bag_has_less_items : With_initialized_bag
+        {
+            public override void establish_context()
+            {
+                base.establish_context();
+                target.GetterAndSetter = new[] {"foo", "bar"};
+            }
+
+            public override void because()
+            {
+                sut.CheckValue(target);
+            }
+
+            [Test]
+            public void should_throw_exception()
+            {
+                thrown_exception.ShouldBeOfType(typeof(ApplicationException));
+            }
+
+            [Test]
+            public void should_state_that_bag_doesnt_match()
+            {
+                var exception = (ApplicationException)thrown_exception;
+                exception.Message.ShouldEqual("Actual count (2) does not equal expected count (3)");
+            }
+        }
+
+        [TestFixture]
+        public class when_the_checked_list_has_different_elements : With_initialized_bag
+        {
+            public override void establish_context()
+            {
+                base.establish_context();
+                target.GetterAndSetter = new[] {"bad", "bar", "foo"};
+            }
+
+            public override void because()
+            {
+                sut.CheckValue(target);
+            }
+
+            [Test]
+            public void should_throw_exception()
+            {
+                thrown_exception.ShouldBeOfType(typeof(ApplicationException));
+            }
+
+            [Test]
+            public void should_state_that_bag_doesnt_match()
+            {
+                var exception = (ApplicationException)thrown_exception;
+                exception.Message.ShouldEqual("Actual count of item bad (1) does not equal expected item count (0)");
+            }
+        }
+
+        [TestFixture]
+        public class When_the_checked_list_has_transposed_items_of_the_expected_list : With_initialized_bag
+        {
+            public override void establish_context()
+            {
+                base.establish_context();
+                target.GetterAndSetter = new[] { "baz", "bar", "foo" };
+            }
+
+            public override void because()
+            {
+                sut.CheckValue(target);
+            }
+
+            [Test]
+            public void should_succeed()
+            {
+                thrown_exception.ShouldBeNull();
+            }
+        } 
+    }
+}

src/FluentNHibernate/FluentNHibernate.csproj

@@ -450,6 +450,7 @@
     <Compile Include="Mapping\Providers\IPropertyMappingProvider.cs" />
     <Compile Include="Mapping\Providers\IReferenceComponentMappingProvider.cs" />
     <Compile Include="Mapping\TuplizerPart.cs" />
+    <Compile Include="Testing\Values\ReferenceBag.cs" />
     <Compile Include="Utils\StringLikeness.cs" />
     <Compile Include="Visitors\AmbiguousComponentReferenceException.cs" />
     <Compile Include="Visitors\RelationshipKeyPairingVisitor.cs" />

src/FluentNHibernate/Testing/PersistenceSpecification.cs

@@ -87,6 +87,13 @@ public PersistenceSpecification<T> RegisterCheckedProperty(Property<T> property)
             return RegisterCheckedProperty(property, null);
         }
 
+        public PersistenceSpecification<T> RegisterCheckedPropertyWithoutTransactionalSave(Property<T> property, IEqualityComparer equalityComparer)
+        {
+            property.EntityEqualityComparer = equalityComparer ?? entityEqualityComparer;
+            allProperties.Add(property);
+
+            return this;
+        }
         public PersistenceSpecification<T> RegisterCheckedProperty(Property<T> property, IEqualityComparer equalityComparer)
         {
             property.EntityEqualityComparer = equalityComparer ?? entityEqualityComparer;