Commit pull #174 (only half the fix is accepted)

Author: JonathanMagnan

GraphDiff/GraphDiff.Shared/Internal/Graph/CollectionGraphNode.cs

@@ -83,18 +83,24 @@ private object AddElement<T>(DbContext context, T existing, object updateItem, o
                 var entityType = ObjectContext.GetObjectType(updateItem.GetType());
                 var instance = CreateEmptyEntityWithKey(context, updateItem);
 
-                context.Set(entityType).Add(instance);
-                context.Entry(instance).CurrentValues.SetValues(updateItem);
-
-                foreach (var childMember in Members)
+                if (!(bool) dbCollection.GetType().GetMethod("Contains").Invoke(dbCollection, new[] {updateItem}))
                 {
-                    childMember.Update(context, instance, updateItem);
+                    context.Set(entityType).Add(instance);
+                    context.Entry(instance).CurrentValues.SetValues(updateItem);
+
+                    foreach (var childMember in Members)
+                    {
+                        childMember.Update(context, instance, updateItem);
+                    }
                 }
 
                 updateItem = instance;
             }
 
-            dbCollection.GetType().GetMethod("Add").Invoke(dbCollection, new[] {updateItem});
+            if (!(bool)dbCollection.GetType().GetMethod("Contains").Invoke(dbCollection, new[] { updateItem }))
+            {
+                dbCollection.GetType().GetMethod("Add").Invoke(dbCollection, new[] { updateItem });
+            }
 
             AttachCyclicNavigationProperty(context, existing, updateItem);
 

GraphDiff/GraphDiff.Shared/Internal/Graph/OwnedEntityGraphNode.cs

@@ -36,12 +36,24 @@ public override void Update<T>(DbContext context, T persisted, T updating)
 
             AttachCyclicNavigationProperty(context, persisted, newValue);
 
+            // if (dbValue != null) // make an error throw or not?
             foreach (var childMember in Members)
                 childMember.Update(context, dbValue, newValue);
         }
 
         private object CreateNewPersistedEntity<T>(DbContext context, T existing, object newValue) where T : class, new()
         {
+            // TBD_79ad60a7-8091-4d0c-b5de-7373f3b8cedf: Could be accepted with an option. Otherwise, we cannot allow people by default to provide multiple entity with same ID if it's not the same.
+            //var local = context.Set(Accessor.PropertyType).Local;
+            //foreach (var entity in local)
+            //{
+            //    if (entity.Equals(newValue))
+            //    {
+            //        SetValue(existing, entity);
+            //        return entity;
+            //    }
+            //}
+
             var instance = Activator.CreateInstance(newValue.GetType());
             SetValue(existing, instance);
             context.Set(Accessor.PropertyType).Add(instance);

GraphDiff/GraphDiff.Tests.Shared/Models/TestModels.cs

@@ -240,4 +240,59 @@ public class OneToOneOneToManyAssociatedModel : Entity
     {
         public OneToOneOwnedModel OneParent { get; set; }
     }
+
+    public class ModelRoot
+    {
+        public Guid Id { get; set; }
+        public virtual ICollection<ModelLevel1> MyModelsLevel1 { get; set; }
+    }
+
+    public class ModelLevel1
+    {
+        protected bool Equals(ModelLevel1 other)
+        {
+            return Id.Equals(other.Id);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((ModelLevel1)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Id.GetHashCode();
+        }
+
+        public Guid Id { get; set; }
+
+        public virtual ModelLevel2 ModelLevel2 { get; set; }
+    }
+
+    public class ModelLevel2
+    {
+        protected bool Equals(ModelLevel2 other)
+        {
+            return Code.Equals(other.Code);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((ModelLevel2)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Code.GetHashCode();
+        }
+
+        public Guid Code { get; set; }
+        public string Name { get; set; }
+    }
 }

GraphDiff/GraphDiff.Tests.Shared/TestDbContext.cs

@@ -68,7 +68,11 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder)
 
             modelBuilder.Entity<InternalKeyModel>()
                     .HasMany(ikm => ikm.Associates)
-		            .WithRequired(ikm => ikm.Parent); 
+		            .WithRequired(ikm => ikm.Parent);
+
+            modelBuilder.Entity<ModelRoot>().HasKey(x => x.Id).HasMany(x => x.MyModelsLevel1);
+            modelBuilder.Entity<ModelLevel1>().HasKey(x => x.Id).HasOptional(x => x.ModelLevel2);
+            modelBuilder.Entity<ModelLevel2>().HasKey(x => x.Code);
         }
 
         public TestDbContext() : base("Server=localhost;Initial Catalog=GraphDiff;Integrated Security=true;Connection Timeout = 300;Persist Security Info=True;") {}

GraphDiff/GraphDiff.Tests.Shared/Tests/AddAggregateBehaviours.cs

@@ -1,4 +1,5 @@
-using System.Data.Entity;
+using System;
+using System.Data.Entity;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using RefactorThis.GraphDiff.Tests.Models;
 using System.Linq;
@@ -9,6 +10,69 @@ namespace RefactorThis.GraphDiff.Tests.Tests
     [TestClass]
     public class AddAggregateBehaviours : TestBase
     {
+        [TestMethod]
+        public void ShouldAddNewAggregateRootWithDuplicateEntityOnLevel1()
+        {
+            var guid = Guid.Parse("C1775DA8-61EC-47A1-ADF9-A50653820061");
+
+            var node1 = new ModelRoot()
+            {
+                Id = Guid.NewGuid(),
+                MyModelsLevel1 = new List<ModelLevel1>()
+                {
+                    new ModelLevel1() {Id = guid},
+                    new ModelLevel1() {Id = guid}
+                }
+            };
+
+            using (var context = new TestDbContext())
+            {
+                node1 = context.UpdateGraph(node1, map =>
+                    map.OwnedCollection(p => p.MyModelsLevel1,
+                        with => with.OwnedEntity(p => p.ModelLevel2)));
+
+                context.SaveChanges();
+            }
+
+            using (var context = new TestDbContext())
+            {
+                var model = context.Set<ModelRoot>().Include(x => x.MyModelsLevel1).FirstOrDefault();
+                Assert.IsTrue(model.MyModelsLevel1.All(x => x.Id == guid));
+            }
+        }
+
+        [TestMethod]
+        public void ShouldAddNewAggregateRootWithduplicateEntityOnLevel2()
+        {
+            // See TBD_79ad60a7-8091-4d0c-b5de-7373f3b8cedf
+            //var guid = Guid.Parse("C1775DA8-61EC-47A1-ADF9-A50653820061");
+
+            //var node1 = new ModelRoot()
+            //{
+            //    Id = Guid.NewGuid(),
+            //    MyModelsLevel1 = new List<ModelLevel1>()
+            //    {
+            //        new ModelLevel1() {Id = Guid.NewGuid(), ModelLevel2 = new ModelLevel2() {Code = guid}},
+            //        new ModelLevel1() {Id = Guid.NewGuid(), ModelLevel2 = new ModelLevel2() {Code = guid}}
+            //    }
+            //};
+
+            //using (var context = new TestDbContext())
+            //{
+            //    node1 = context.UpdateGraph(node1, map =>
+            //        map.OwnedCollection(p => p.MyModelsLevel1,
+            //            with => with.OwnedEntity(p => p.ModelLevel2)));
+
+            //    context.SaveChanges();
+            //}
+
+            //using (var context = new TestDbContext())
+            //{
+            //    var models = context.Set<ModelLevel1>().Include(x => x.ModelLevel2).ToList();
+            //    Assert.IsTrue(models.All(x => x.ModelLevel2.Code == guid));
+            //}
+        }
+
         [TestMethod]
         public void ShouldAddNewAggregateRoot_Detached()
         {
@@ -44,7 +108,7 @@ public void ShouldAddNewAggregateRoot_Detached()
                 node1 = context.UpdateGraph(node1, map => map
                     .OwnedEntity(p => p.OneToOneOwned)
                     .AssociatedEntity(p => p.OneToOneAssociated)
-                    .OwnedCollection(p => p.OneToManyOwned)
+                    .OwnedCollection(p => p.OneToManyOwned, with => with.OwnedEntity(p => p.OneToManyOneToOneOwned))
                     .AssociatedCollection(p => p.OneToManyAssociated));
 
                 context.SaveChanges();