public void ShouldBeAbleToVisitExpressionsStoredAsProperties()
        {
            var node1 = new TestNode
            {
                Title = "One",
                OneToOneOwned = new OneToOneOwnedModel { Title = "Hello" }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToOneOwned.Title = "Hey2";

            Lambda = (p => p.OneToOneOwned);
            Expression<Func<IUpdateConfiguration<TestNode>, dynamic>> exp = map => map.OwnedEntity(Lambda);

            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, exp);

                context.SaveChanges();
                Assert.IsTrue(context.Nodes
                    .Include(p => p.OneToOneOwned)
                    .Single(p => p.Id == node1.Id)
                    .OneToOneOwned.Title == "Hey2");
            }
        }
        public void ShouldAddRelationIfPreviousValueWasNull()
        {
            var node1 = new TestNode { Title = "New Node" };
            var associated = new OneToOneAssociatedModel { Title = "Associated Node" };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.OneToOneAssociatedModels.Add(associated);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToOneAssociated = associated;

            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .AssociatedEntity(p => p.OneToOneAssociated));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToOneAssociated).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.IsTrue(node2.OneToOneAssociated.OneParent == node2);
            }
        }
Exemplo n.º 3
0
        public void ShouldSupportNullValuesInTree()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToOneOwned = null
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            using (var context = new TestDbContext())
            {
                // Setup mapping
                node1 = context.UpdateGraph(node1, map => map
                    .OwnedEntity(p => p.OneToOneOwned, with =>
                        with.OwnedEntity(p => p.OneToOneOneToOneOwned)));

                context.SaveChanges();
                context.Entry(node1).Reload();
                Assert.IsTrue(node1.OneToOneOwned == null);
            }
        }
        public void ShouldUpdateItemInOwnedCollection()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToManyOwned = new List<OneToManyOwnedModel>
                {
                    new OneToManyOwnedModel { Title = "Hello" }
                }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToManyOwned.First().Title = "What's up";
            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedCollection(p => p.OneToManyOwned));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToManyOwned).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                var owned = node2.OneToManyOwned.First();
                Assert.IsTrue(owned.OneParent == node2 && owned.Title == "What's up");
            }
        }
        public void ShouldThrowDbUpdateConcurrencyExceptionWithEmptyRowVersion()
        {
            TestNode node;
            using (var db = new TestDbContext())
            {
                node = new TestNode
                {
                    Title = "Hello",
                    OneToManyOwned = new List<OneToManyOwnedModel>
                    {
                        new OneToManyOwnedModel { Title = "Test1" },
                        new OneToManyOwnedModel { Title = "Test2" }
                    }
                };
                db.Nodes.Add(node);
                db.SaveChanges();
            }

            using (var db = new TestDbContext())
            {
                node.OneToManyOwned.First().RowVersion = null;
                db.UpdateGraph(node, map => map.OwnedCollection(p => p.OneToManyOwned));
                db.SaveChanges();
            }
        }
        public void ShouldUpdateItemInNestedOwnedCollection()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToManyOwned = new List<OneToManyOwnedModel>
                {
                    new OneToManyOwnedModel
                    {
                        Title = "Hello",
                        OneToManyOneToManyOwned = new Collection<OneToManyOneToManyOwnedModel>
                        {
                            new OneToManyOneToManyOwnedModel {Title = "BeforeUpdate"}
                        }
                    }
                }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            var oneToManyOneToManyOwned = node1.OneToManyOwned.Single().OneToManyOneToManyOwned.Single();
            var expectedId = oneToManyOneToManyOwned.Id;
            const string expectedTitle = "AfterUpdate";
            oneToManyOneToManyOwned.Title = expectedTitle;

            using (var context = new TestDbContext())
            {
                // Setup mapping
                node1 = context.UpdateGraph(node1, map => map.OwnedCollection(p => p.OneToManyOwned,
                                                                              with => with.OwnedCollection(p => p.OneToManyOneToManyOwned)));
                context.SaveChanges();

                Assert.AreEqual(1, node1.OneToManyOwned.Count);
                Assert.AreEqual(1, node1.OneToManyOwned.Single().OneToManyOneToManyOwned.Count);

                oneToManyOneToManyOwned = node1.OneToManyOwned.Single().OneToManyOneToManyOwned.Single();
                Assert.AreEqual(expectedId, oneToManyOneToManyOwned.Id);
                Assert.AreEqual(expectedTitle, oneToManyOneToManyOwned.Title);

                var node1Reloaded = context.Nodes
                        .Include("OneToManyOwned.OneToManyOneToManyOwned")
                        .Single(n => n.Id == node1.Id);

                Assert.AreEqual(1, node1Reloaded.OneToManyOwned.Count);
                Assert.AreEqual(1, node1Reloaded.OneToManyOwned.Single().OneToManyOneToManyOwned.Count);

                oneToManyOneToManyOwned = node1Reloaded.OneToManyOwned.Single().OneToManyOneToManyOwned.Single();
                Assert.AreEqual(expectedId, oneToManyOneToManyOwned.Id);
                Assert.AreEqual(expectedTitle, oneToManyOneToManyOwned.Title);
            }
        }
Exemplo n.º 7
0
        public void ShouldAddSingleEntity()
        {
            var node1 = new TestNode
            {
                Title = "Hello"
            };

            using (var context = new TestDbContext())
            {
                node1 = context.UpdateGraph(node1);
                context.SaveChanges();
                Assert.IsNotNull(context.Nodes.SingleOrDefault(p => p.Id == node1.Id));
            }
        }
Exemplo n.º 8
0
        public void ShouldNotUpdateEntityIfNoChangesHaveBeenMade_Detached()
        {
            var node1 = new TestNode
            {
                Title = "Hello"
            };

            using (var context = new TestDbContext())
            {
                node1 = context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            using (var context = new TestDbContext())
            {
                context.UpdateGraph(node1);
                Assert.IsTrue(context.ChangeTracker.Entries().All(p => p.State == EntityState.Unchanged));
                context.SaveChanges();
            }
        }
Exemplo n.º 9
0
        public void ShouldUpdateSingleEntity_Detached()
        {
            var node1 = new TestNode
            {
                Title = "Hello"
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.Title = "Hello2";

            using (var context = new TestDbContext())
            {
                context.UpdateGraph(node1);
                context.SaveChanges();
                Assert.IsTrue(context.Nodes.Single(p => p.Id == node1.Id).Title == "Hello2");
            }
        }
Exemplo n.º 10
0
        public void ShouldUpdateValuesOfEntityWhenEntityAlreadyExists()
        {
            var node1 = new TestNode { Title = "New Node", OneToOneOwned = new OneToOneOwnedModel { Title = "New Entity" } };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToOneOwned.Title = "Newer Entity";
            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedEntity(p => p.OneToOneOwned));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToOneOwned).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.IsTrue(node2.OneToOneOwned.OneParent == node2 && node2.OneToOneOwned.Title == "Newer Entity");
            }
        }
        public void ShouldThrowDbUpdateConcurrencyExceptionIfEditingOutOfDateModel()
        {
            TestNode node;
            using (var db = new TestDbContext())
            {
                node = new TestNode { Title = "Hello" };
                db.Nodes.Add(node);
                db.SaveChanges();
            }

            using (var db = new TestDbContext())
            {
                var node2 = new TestNode
                {
                    RowVersion = new byte[] { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1 },
                    Id = node.Id,
                    Title = "Test2"
                };

                db.UpdateGraph(node2);
                db.SaveChanges();
            }
        }
        public void ShouldRemoveItemsInOwnedCollectionWhenSetToNull()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToManyOwned = new List<OneToManyOwnedModel>
                {
                    new OneToManyOwnedModel { Title = "Hello" },
                    new OneToManyOwnedModel { Title = "Hello2" },
                    new OneToManyOwnedModel { Title = "Hello3" }
                }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToManyOwned = null;
            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedCollection(p => p.OneToManyOwned));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToManyOwned).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.IsTrue(node2.OneToManyOwned.Count == 0);
            }
        }
Exemplo n.º 13
0
        public void ShouldSupportOwnedEntityWithNestedModels()
        {
            // setup
            var oneToOneAssociated = new OneToOneOneToOneAssociatedModel { Title = "Associated Update" };
            var oneToManyAssociated = new OneToOneOneToManyAssociatedModel { Title = "Many Associated Update" };
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToOneOwned = new OneToOneOwnedModel
                {
                    OneToOneOneToOneAssociated = new OneToOneOneToOneAssociatedModel { Title = "Hello" },
                    OneToOneOneToOneOwned = new OneToOneOneToOneOwnedModel { Title = "Hello" },
                    OneToOneOneToManyAssociated = new List<OneToOneOneToManyAssociatedModel>
                    {
                        new OneToOneOneToManyAssociatedModel { Title = "Hello" },
                        new OneToOneOneToManyAssociatedModel { Title = "Hello" }
                    },
                    OneToOneOneToManyOwned = new List<OneToOneOneToManyOwnedModel>
                    {
                        new OneToOneOneToManyOwnedModel { Title = "Hello" },
                        new OneToOneOneToManyOwnedModel { Title = "Hello" },
                        new OneToOneOneToManyOwnedModel { Title = "Hello" }
                    }
                }
            };

            using (var context = new TestDbContext())
            {
                context.Set<OneToOneOneToOneAssociatedModel>().Add(oneToOneAssociated);
                context.Set<OneToOneOneToManyAssociatedModel>().Add(oneToManyAssociated);
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            // change
            node1.OneToOneOwned.OneToOneOneToOneOwned.Title = "Updated";
            node1.OneToOneOwned.OneToOneOneToOneAssociated = oneToOneAssociated;

            var owned = node1.OneToOneOwned.OneToOneOneToManyOwned;
            owned.Remove(owned.First());
            owned.First().Title = "Updated";
            owned.Skip(1).First().Title = "Updated 2";
            owned.Add(new OneToOneOneToManyOwnedModel { Title = "A new one" });

            var associated = node1.OneToOneOwned.OneToOneOneToManyAssociated;
            associated.Remove(associated.First());
            associated.Add(oneToManyAssociated);

            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedEntity(p => p.OneToOneOwned, with => with
                        .OwnedEntity(p => p.OneToOneOneToOneOwned)
                        .AssociatedEntity(p => p.OneToOneOneToOneAssociated)
                        .OwnedCollection(p => p.OneToOneOneToManyOwned)
                        .AssociatedCollection(p => p.OneToOneOneToManyAssociated)));

                context.SaveChanges();

                var updated = context.Set<OneToOneOwnedModel>().Single();
                Assert.IsNotNull(updated);
                Assert.IsTrue(updated.OneToOneOneToOneOwned.Title == "Updated");
                Assert.IsTrue(updated.OneToOneOneToOneAssociated.Title == "Associated Update");

                var ownershipList = updated.OneToOneOneToManyOwned.ToList();
                Assert.IsTrue(ownershipList.Count == 3);
                Assert.IsTrue(ownershipList[0].Title == "Updated");
                Assert.IsTrue(ownershipList[1].Title == "Updated 2");
                Assert.IsTrue(ownershipList[2].Title == "A new one");

                var associatedList = updated.OneToOneOneToManyAssociated.ToList();
                Assert.IsTrue(associatedList.Count == 2);
                Assert.IsTrue(associatedList[0].Title == "Hello");
                Assert.IsTrue(associatedList[1].Title == "Many Associated Update");
            }
        }
        public void ShouldReplaceReferenceIfNewEntityIsNotPreviousEntity()
        {
            var node1 = new TestNode { 
                Title = "New Node",
                OneToOneAssociated = new OneToOneAssociatedModel { Title = "Associated Node" }
            };
            var otherModel = new OneToOneAssociatedModel { Title = "Hello" };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.OneToOneAssociatedModels.Add(otherModel);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToOneAssociated = otherModel;

            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .AssociatedEntity(p => p.OneToOneAssociated));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToOneAssociated).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.IsTrue(node2.OneToOneAssociated.OneParent == node2);
                // should not delete it as it is associated and no cascade rule set.
                Assert.IsTrue(context.OneToOneAssociatedModels.Single(p => p.Id != otherModel.Id).OneParent == null);
            }
        }
Exemplo n.º 15
0
        public void ShouldUpdateAggregateWithOwnedEntityAndOwnedCollection()
        {
            var node1 = new TestNode
            {
                Title = "New Node"
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            }

            using (var context = new TestDbContext())
            {
                node1.Title = "Newly Updated";
                node1.OneToOneOwned = new OneToOneOwnedModel
                {
                    OneToOneOneToManyOwned = new[]
                    {
                        new OneToOneOneToManyOwnedModel {Title = "One"},
                        new OneToOneOneToManyOwnedModel {Title = "Two"},
                        new OneToOneOneToManyOwnedModel {Title = "Three"}
                    }
                };

                node1 = context.UpdateGraph(node1, map => map.OwnedEntity(p => p.OneToOneOwned, with =>
                    with.OwnedCollection(p => p.OneToOneOneToManyOwned)));
                context.SaveChanges();
            }

            using (var context = new TestDbContext())
            {
                var reload = context.Nodes
                    .Include("OneToOneOwned.OneToOneOneToManyOwned")
                    .SingleOrDefault(p => p.Id == node1.Id);

                Assert.IsNotNull(reload);
                Assert.AreEqual(node1.Title, reload.Title);
                Assert.IsNotNull(reload.OneToOneOwned);
                Assert.AreEqual(node1.OneToOneOwned.Id, reload.OneToOneOwned.Id);

                Assert.IsNotNull(reload.OneToOneOwned.OneToOneOneToManyOwned);
                Assert.AreEqual(3, reload.OneToOneOwned.OneToOneOneToManyOwned.Count);
                Assert.AreEqual(node1.OneToOneOwned.OneToOneOneToManyOwned.First().Id, node1.OneToOneOwned.OneToOneOneToManyOwned.First().Id);

            }
        }
Exemplo n.º 16
0
        public void ShouldSupportOwnedCollectionWithNestedModels()
        {
            // setup
            var oneToOneAssociations = new List<OneToManyOneToOneAssociatedModel>();
            var oneToManyAssociations = new List<OneToManyOneToManyAssociatedModel>();

            var node1 = new TestNode
            {
                Title = "New Node",
                OneToManyOwned = new List<OneToManyOwnedModel>()
            };

            for (var i = 0; i < 3; i++)
            {
                node1.OneToManyOwned.Add(new OneToManyOwnedModel
                {
                    OneToManyOneToOneAssociated = new OneToManyOneToOneAssociatedModel { Title = "Hello" },
                    OneToManyOneToOneOwned = new OneToManyOneToOneOwnedModel { Title = "Hello" },
                    OneToManyOneToManyAssociated = new List<OneToManyOneToManyAssociatedModel>
                        {
                            new OneToManyOneToManyAssociatedModel { Title = "Hello" },
                            new OneToManyOneToManyAssociatedModel { Title = "Hello" }
                        },
                    OneToManyOneToManyOwned = new List<OneToManyOneToManyOwnedModel>
                        {
                            new OneToManyOneToManyOwnedModel { Title = "Hello" },
                            new OneToManyOneToManyOwnedModel { Title = "Hello" },
                            new OneToManyOneToManyOwnedModel { Title = "Hello" }
                        }
                });

                oneToOneAssociations.Add(new OneToManyOneToOneAssociatedModel { Title = "Associated Update" });
                oneToManyAssociations.Add(new OneToManyOneToManyAssociatedModel { Title = "Many Associated Update" + i });
            }

            using (var context = new TestDbContext())
            {
                foreach (var association in oneToOneAssociations)
                {
                    context.Set<OneToManyOneToOneAssociatedModel>().Add(association);
                }
                foreach (var association in oneToManyAssociations)
                {
                    context.Set<OneToManyOneToManyAssociatedModel>().Add(association);
                }
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            // change
            var collection = node1.OneToManyOwned;
            for (var i = 0; i < collection.Count; i++)
            {
                var element = collection.Skip(i).First();
                element.OneToManyOneToOneOwned.Title = "Updated" + i;
                element.OneToManyOneToOneAssociated = oneToOneAssociations[i];

                var owned = element.OneToManyOneToManyOwned;
                owned.Remove(owned.First());
                owned.First().Title = "Updated" + i;
                owned.Skip(1).First().Title = "Updated 2" + i;
                owned.Add(new OneToManyOneToManyOwnedModel { Title = "A new one" + i });

                var associated = element.OneToManyOneToManyAssociated;
                associated.Remove(associated.First());
                associated.Add(oneToManyAssociations[i]);
            }

            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedCollection(p => p.OneToManyOwned, with => with
                        .OwnedEntity(p => p.OneToManyOneToOneOwned)
                        .AssociatedEntity(p => p.OneToManyOneToOneAssociated)
                        .OwnedCollection(p => p.OneToManyOneToManyOwned)
                        .AssociatedCollection(p => p.OneToManyOneToManyAssociated)));

                context.SaveChanges();

                // assert
                node1 = context.Nodes.Single();
                var list = node1.OneToManyOwned.ToList();
                for (var i = 0; i < collection.Count; i++)
                {
                    var element = list[i];
                    Assert.IsNotNull(element);
                    Assert.IsTrue(element.OneToManyOneToOneOwned.Title == "Updated" + i);
                    Assert.IsTrue(element.OneToManyOneToOneAssociated.Title == "Associated Update");

                    var ownershipList = element.OneToManyOneToManyOwned.ToList();
                    Assert.IsTrue(ownershipList.Count == 3);
                    Assert.IsTrue(ownershipList[0].Title == "Updated" + i);
                    Assert.IsTrue(ownershipList[1].Title == "Updated 2" + i);
                    Assert.IsTrue(ownershipList[2].Title == "A new one" + i);

                    var associatedList = element.OneToManyOneToManyAssociated.ToList();
                    Assert.IsTrue(associatedList.Count == 2);
                    Assert.IsTrue(associatedList[0].Title == "Hello");
                    Assert.IsTrue(associatedList[1].Title == "Many Associated Update" + i);
                }
            }
        }
        public void ShouldNotUpdatePropertiesOfAnAssociatedEntity()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToOneAssociated = new OneToOneAssociatedModel { Title = "Associated Node" }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach


            node1.OneToOneAssociated.Title = "Updated Content";

            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .AssociatedEntity(p => p.OneToOneAssociated));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToOneAssociated).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.IsTrue(node2.OneToOneAssociated.OneParent == node2);
                // should not delete it as it is associated and no cascade rule set.
                Assert.IsTrue(node2.OneToOneAssociated.Title == "Associated Node");
            }
        }
        public void ShouldAddNewItemInOwnedCollection()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToManyOwned = new List<OneToManyOwnedModel>
                {
                    new OneToManyOwnedModel { Title = "Hello" }
                }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            var newModel = new OneToManyOwnedModel { Title = "Hi" };
            node1.OneToManyOwned.Add(newModel);

            using (var context = new TestDbContext())
            {
                node1 = context.UpdateGraph(node1, map => map.OwnedCollection(p => p.OneToManyOwned));
                context.SaveChanges();

                var node2 = context.Nodes.Include(p => p.OneToManyOwned).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.AreEqual(2, node2.OneToManyOwned.Count);

                var ownedId = node1.OneToManyOwned.Skip(1).Select(o => o.Id).Single();
                var owned = context.OneToManyOwnedModels.Single(p => p.Id == ownedId);
                Assert.IsTrue(owned.OneParent == node2 && owned.Title == "Hi");
            }
        }
        public void ShouldMergeTwoCollectionsAndDecideOnUpdatesDeletesAndAdds()
        {
            var node1 = new TestNode
            {
                Title = "New Node",
                OneToManyOwned = new List<OneToManyOwnedModel>
                {
                    new OneToManyOwnedModel { Title = "This" },
                    new OneToManyOwnedModel { Title = "Is" },
                    new OneToManyOwnedModel { Title = "A" },
                    new OneToManyOwnedModel { Title = "Test" }
                }
            };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToManyOwned.Remove(node1.OneToManyOwned.First());
            node1.OneToManyOwned.First().Title = "Hello";
            node1.OneToManyOwned.Add(new OneToManyOwnedModel { Title = "Finish" });
            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedCollection(p => p.OneToManyOwned));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToManyOwned).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                var list = node2.OneToManyOwned.ToList();
                Assert.IsTrue(list[0].Title == "Hello");
                Assert.IsTrue(list[1].Title == "A");
                Assert.IsTrue(list[2].Title == "Test");
                Assert.IsTrue(list[3].Title == "Finish");
            }
        }
Exemplo n.º 20
0
        public void ShouldRemoveEntityIfRemovedFromParent()
        {
            var oneToOne = new OneToOneOwnedModel { Title = "New Entity" };
            var node1 = new TestNode { Title = "New Node", OneToOneOwned = oneToOne };

            using (var context = new TestDbContext())
            {
                context.Nodes.Add(node1);
                context.SaveChanges();
            } // Simulate detach

            node1.OneToOneOwned = null;
            using (var context = new TestDbContext())
            {
                // Setup mapping
                context.UpdateGraph(node1, map => map
                    .OwnedEntity(p => p.OneToOneOwned));

                context.SaveChanges();
                var node2 = context.Nodes.Include(p => p.OneToOneOwned).Single(p => p.Id == node1.Id);
                Assert.IsNotNull(node2);
                Assert.IsNull(context.OneToOneOwnedModels.SingleOrDefault(p => p.Id == oneToOne.Id));
            }
        }