public async Task CanMergeWithTransientChildAsync()
{
using (var session = OpenSession())
{
var parent = new Entity {
Name = "Parent"
};
using (var t = session.BeginTransaction())
{
await(session.PersistAsync(parent));
await(t.CommitAsync());
}
var child = new ChildEntity {
Name = "Child"
};
using (var t = session.BeginTransaction())
{
parent.Children.Add(child);
await(session.MergeAsync(parent));
await(t.CommitAsync());
}
Assert.That(parent.Children, Has.Count.EqualTo(1));
// Merge should duplicate child and leave original instance un-associated with the session.
Assert.That(parent.Children, Does.Not.Contain(child));
Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
}
}
public async Task CanChangeOwnershipOnNonFlushedParentsAsync()
{
// Seems moot but why not still checking this?
var parent = new EntityWithoutDeleteOrphan {
Name = "Parent"
};
var nextParent = new EntityWithoutDeleteOrphan {
Name = "NextParent"
};
var child = new ChildEntity {
Name = "Child"
};
using (var session = OpenSession())
{
using (var t = session.BeginTransaction())
{
await(session.PersistAsync(parent));
parent.Children.Add(child);
await(session.PersistAsync(nextParent));
nextParent.Children = parent.Children;
parent.Children = new HashSet <ChildEntity>();
await(t.CommitAsync());
}
Assert.That(parent.Children, Has.Count.EqualTo(0));
Assert.That(nextParent.Children, Has.Count.EqualTo(1));
Assert.That(nextParent.Children, Does.Contain(child));
Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
}
using (var session = OpenSession())
{
// Check after a reload
parent = await(session.LoadAsync <EntityWithoutDeleteOrphan>(parent.Id));
nextParent = await(session.LoadAsync <EntityWithoutDeleteOrphan>(nextParent.Id));
child = await(session.LoadAsync <ChildEntity>(child.Id));
Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
}
}
public void CanChangeOwnershipFromNonFlushedParentToFlushed()
{
var parent = new EntityWithoutDeleteOrphan {
Name = "Parent"
};
var nextParent = new EntityWithoutDeleteOrphan {
Name = "NextParent"
};
var child = new ChildEntity {
Name = "Child"
};
using (var session = OpenSession())
{
using (var t = session.BeginTransaction())
{
session.Persist(nextParent);
session.Flush();
session.Persist(parent);
parent.Children.Add(child);
nextParent.Children = parent.Children;
parent.Children = new HashSet <ChildEntity>();
t.Commit();
}
Assert.That(parent.Children, Has.Count.EqualTo(0));
Assert.That(nextParent.Children, Has.Count.EqualTo(1));
Assert.That(nextParent.Children, Does.Contain(child));
Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0));
}
using (var session = OpenSession())
{
// Check after a reload
parent = session.Load <EntityWithoutDeleteOrphan>(parent.Id);
nextParent = session.Load <EntityWithoutDeleteOrphan>(nextParent.Id);
child = session.Load <ChildEntity>(child.Id);
Assert.That(parent.Children, Has.Count.EqualTo(0), "Reloaded data");
Assert.That(nextParent.Children, Has.Count.EqualTo(1), "Reloaded data");
Assert.That(nextParent.Children, Does.Contain(child), "Reloaded data");
Assert.That(nextParent.Children.Single().Id, Is.Not.EqualTo(0), "Reloaded data");
}
}
public async Task CanAddChildAfterFlushWithoutTransactionAsync()
{
using (var session = OpenSession())
{
var parent = new Entity {
Name = "Parent"
};
var child = new ChildEntity {
Name = "Child"
};
await(session.PersistAsync(parent));
await(session.FlushAsync());
parent.Children.Add(child);
await(session.FlushAsync());
Assert.That(parent.Children, Has.Count.EqualTo(1));
Assert.That(parent.Children, Does.Contain(child));
Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
}
}
public void CanAddChildAfterFlush()
{
using (var session = OpenSession())
{
var parent = new Entity {
Name = "Parent"
};
var child = new ChildEntity {
Name = "Child"
};
using (var t = session.BeginTransaction())
{
session.Persist(parent);
session.Flush();
parent.Children.Add(child);
t.Commit();
}
Assert.That(parent.Children, Has.Count.EqualTo(1));
Assert.That(parent.Children, Does.Contain(child));
Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
}
}
public void CanMergeWithTransientChildWithoutTransaction()
{
using (var session = OpenSession())
{
var parent = new Entity {
Name = "Parent"
};
session.Persist(parent);
session.Flush();
var child = new ChildEntity {
Name = "Child"
};
parent.Children.Add(child);
session.Merge(parent);
session.Flush();
Assert.That(parent.Children, Has.Count.EqualTo(1));
// Merge should duplicate child and leave original instance un-associated with the session.
Assert.That(parent.Children, Does.Not.Contain(child));
Assert.That(parent.Children.Single().Id, Is.Not.EqualTo(0));
}
}
