public virtual async Task CreateWithNonEmptyOneToManyCollectionOfExistingAsync()
{
ClearCounts();
Party party = new Party("party");
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(party));
await(t.CommitAsync());
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
c.AddParty(party);
s = OpenSession();
t = s.BeginTransaction();
await(s.SaveAsync(c));
await(t.CommitAsync());
s.Close();
AssertInsertCount(1);
// BUG, should be assertUpdateCount( ! isContractPartiesInverse && isPartyVersioned ? 1 : 0 );
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
party = await(s.CreateCriteria <Party>().UniqueResultAsync <Party>());
Assert.That(party.Contract, Is.Null);
await(s.DeleteAsync(party));
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
}
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual void OneToManyCollectionOptimisticLockingWithUpdate()
{
ClearCounts();
Contract cOrig = new Contract(null, "gail", "phone");
Party partyOrig = new Party("party");
cOrig.AddParty(partyOrig);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(cOrig);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
Contract c = s.Get <Contract>(cOrig.Id);
Party newParty = new Party("new party");
c.AddParty(newParty);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
cOrig.RemoveParty(partyOrig);
s.Update(cOrig);
try
{
t.Commit();
Assert.That(isContractVersioned, Is.False);
}
catch (StaleObjectStateException)
{
Assert.That(isContractVersioned, Is.True);
t.Rollback();
}
s.Close();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria <Contract>().UniqueResult <Contract>();
s.CreateQuery("delete from Party").ExecuteUpdate();
s.Delete(c);
Assert.That(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
}
public virtual async Task UpdatePropertyAsync()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
c.AddParty(new Party("party"));
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(c));
await(t.CommitAsync());
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
c.CustomerName = "yogi";
Assert.That(c.Parties.Count, Is.EqualTo(1));
Party party = c.Parties.First();
party.Name = "new party";
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual async Task RemoveOneToManyElementByDeleteAsync()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(c));
await(t.CommitAsync());
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
c.RemoveParty(party);
Assert.That(c.Parties.Count, Is.EqualTo(0));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.Null);
}
s = OpenSession();
t = s.BeginTransaction();
await(s.UpdateAsync(c));
await(s.DeleteAsync(party));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(isContractVersioned ? 1 : 0);
AssertDeleteCount(1);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
Assert.That(c.Parties.Count, Is.EqualTo(0));
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(1);
}
public virtual void UpdateProperty()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
c.AddParty(new Party("party"));
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
c.CustomerName = "yogi";
Assert.That(c.Parties.Count, Is.EqualTo(1));
Party party = c.Parties.First();
party.Name = "new party";
t.Commit();
s.Close();
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
s.Delete(c);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual void AddNewOneToManyElementToPersistentEntity()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.Get <Contract>(c.Id);
Assert.That(c.Parties.Count, Is.EqualTo(0));
c.AddParty(new Party("party"));
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria <Contract>().UniqueResult <Contract>();
Assert.That(c.Parties.Count, Is.EqualTo(1));
Party party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
s.Delete(c);
Assert.That(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual void DeleteOneToManyElement()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
s.Update(c);
c.RemoveParty(party);
s.Delete(party);
t.Commit();
s.Close();
AssertUpdateCount(isContractVersioned ? 1 : 0);
AssertDeleteCount(1);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria <Contract>().UniqueResult <Contract>();
Assert.That(c.Parties.Count, Is.EqualTo(0));
party = s.CreateCriteria <Party>().UniqueResult <Party>();
Assert.That(party, Is.Null);
s.Delete(c);
Assert.That(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(1);
}
public virtual void RemoveOneToManyElementByDelete()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
c.RemoveParty(party);
Assert.That(c.Parties.Count, Is.EqualTo(0));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.Null);
}
s = OpenSession();
t = s.BeginTransaction();
s.Update(c);
s.Delete(party);
t.Commit();
s.Close();
AssertUpdateCount(isContractVersioned ? 1 : 0);
AssertDeleteCount(1);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
Assert.That(c.Parties.Count, Is.EqualTo(0));
s.Delete(c);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(1);
}
public virtual void RemoveOneToManyElementUsingMerge()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
c.RemoveParty(party);
Assert.That(c.Parties.Count, Is.EqualTo(0));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.Null);
}
s = OpenSession();
t = s.BeginTransaction();
c = (Contract)s.Merge(c);
party = (Party)s.Merge(party);
t.Commit();
s.Close();
if (CheckUpdateCountsAfterRemovingElementWithoutDelete())
{
AssertUpdateCount(isContractVersioned && !isContractPartiesInverse ? 1 : 0);
}
AssertDeleteCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
Assert.That(party.Contract, Is.SameAs(c));
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
party = s.CreateCriteria<Party>().UniqueResult<Party>();
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.Null);
}
s.Delete(party);
}
s.Delete(c);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual void MoveOneToManyElementToExistingEntityCollection()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
c.AddParty(new Party("party"));
Contract c2 = new Contract(null, "david", "phone");
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
s.Persist(c2);
t.Commit();
s.Close();
AssertInsertCount(3);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().Add(Restrictions.IdEq(c.Id)).UniqueResult<Contract>();
Assert.That(c.Parties.Count, Is.EqualTo(1));
Party party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
c.RemoveParty(party);
c2 = s.CreateCriteria<Contract>().Add(Restrictions.IdEq(c2.Id)).UniqueResult<Contract>();
c2.AddParty(party);
t.Commit();
s.Close();
AssertInsertCount(0);
AssertUpdateCount(isContractVersioned ? 2 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().Add(Restrictions.IdEq(c.Id)).UniqueResult<Contract>();
c2 = s.CreateCriteria<Contract>().Add(Restrictions.IdEq(c2.Id)).UniqueResult<Contract>();
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
Assert.That(c2.Parties.Count, Is.EqualTo(0));
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
Assert.That(c2.Parties.Count, Is.EqualTo(1));
party = c2.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c2));
}
}
s.Delete(c);
s.Delete(c2);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(3);
}
public virtual void CreateWithNonEmptyOneToManyCollectionMergeWithNewElement()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
Party newParty = new Party("new party");
c.AddParty(newParty);
s = OpenSession();
t = s.BeginTransaction();
c = (Contract)s.Merge(c);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
Assert.That(c.Parties.Count, Is.EqualTo(2));
foreach (Party aParty in c.Parties)
{
if (aParty.Id == party.Id)
{
Assert.That(aParty.Name, Is.EqualTo("party"));
}
else if (!aParty.Name.Equals(newParty.Name))
{
Assert.Fail("unknown party:" + aParty.Name);
}
if (isContractPartiesBidirectional)
{
Assert.That(aParty.Contract, Is.SameAs(c));
}
}
s.Delete(c);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(3);
}
public virtual void CreateWithNonEmptyOneToManyCollectionOfExisting()
{
ClearCounts();
Party party = new Party("party");
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(party);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
c.AddParty(party);
s = OpenSession();
t = s.BeginTransaction();
s.Save(c);
t.Commit();
s.Close();
AssertInsertCount(1);
// BUG, should be assertUpdateCount( ! isContractPartiesInverse && isPartyVersioned ? 1 : 0 );
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
party = s.CreateCriteria<Party>().UniqueResult<Party>();
Assert.That(party.Contract, Is.Null);
s.Delete(party);
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
}
s.Delete(c);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual void OneToManyCollectionOptimisticLockingWithUpdate()
{
ClearCounts();
Contract cOrig = new Contract(null, "gail", "phone");
Party partyOrig = new Party("party");
cOrig.AddParty(partyOrig);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(cOrig);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
Contract c = s.Get<Contract>(cOrig.Id);
Party newParty = new Party("new party");
c.AddParty(newParty);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
cOrig.RemoveParty(partyOrig);
s.Update(cOrig);
try
{
t.Commit();
Assert.That(isContractVersioned, Is.False);
}
catch (StaleObjectStateException)
{
Assert.That(isContractVersioned, Is.True);
t.Rollback();
}
s.Close();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria<Contract>().UniqueResult<Contract>();
s.CreateQuery("delete from Party").ExecuteUpdate();
s.Delete(c);
Assert.That(s.CreateCriteria<Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria<Party>().SetProjection(Projections.RowCountInt64()).UniqueResult<long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
}
public virtual async Task RemoveOneToManyElementUsingMergeAsync()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(c));
await(t.CommitAsync());
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
c.RemoveParty(party);
Assert.That(c.Parties.Count, Is.EqualTo(0));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.Null);
}
s = OpenSession();
t = s.BeginTransaction();
c = (Contract)await(s.MergeAsync(c));
party = (Party)await(s.MergeAsync(party));
await(t.CommitAsync());
s.Close();
if (CheckUpdateCountsAfterRemovingElementWithoutDelete())
{
AssertUpdateCount(isContractVersioned && !isContractPartiesInverse ? 1 : 0);
}
AssertDeleteCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
Assert.That(party.Contract, Is.SameAs(c));
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
party = await(s.CreateCriteria <Party>().UniqueResultAsync <Party>());
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.Null);
}
await(s.DeleteAsync(party));
}
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual async Task MoveOneToManyElementToExistingEntityCollectionAsync()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
c.AddParty(new Party("party"));
Contract c2 = new Contract(null, "david", "phone");
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(c));
await(s.PersistAsync(c2));
await(t.CommitAsync());
s.Close();
AssertInsertCount(3);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().Add(Restrictions.IdEq(c.Id)).UniqueResultAsync <Contract>());
Assert.That(c.Parties.Count, Is.EqualTo(1));
Party party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
c.RemoveParty(party);
c2 = await(s.CreateCriteria <Contract>().Add(Restrictions.IdEq(c2.Id)).UniqueResultAsync <Contract>());
c2.AddParty(party);
await(t.CommitAsync());
s.Close();
AssertInsertCount(0);
AssertUpdateCount(isContractVersioned ? 2 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().Add(Restrictions.IdEq(c.Id)).UniqueResultAsync <Contract>());
c2 = await(s.CreateCriteria <Contract>().Add(Restrictions.IdEq(c2.Id)).UniqueResultAsync <Contract>());
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
Assert.That(c2.Parties.Count, Is.EqualTo(0));
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
Assert.That(c2.Parties.Count, Is.EqualTo(1));
party = c2.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c2));
}
}
await(s.DeleteAsync(c));
await(s.DeleteAsync(c2));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(3);
}
public virtual async Task CreateWithNonEmptyOneToManyCollectionMergeWithNewElementAsync()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
c.AddParty(party);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(c));
await(t.CommitAsync());
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
Party newParty = new Party("new party");
c.AddParty(newParty);
s = OpenSession();
t = s.BeginTransaction();
c = (Contract)await(s.MergeAsync(c));
await(t.CommitAsync());
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
Assert.That(c.Parties.Count, Is.EqualTo(2));
foreach (Party aParty in c.Parties)
{
if (aParty.Id == party.Id)
{
Assert.That(aParty.Name, Is.EqualTo("party"));
}
else if (!aParty.Name.Equals(newParty.Name))
{
Assert.Fail("unknown party:" + aParty.Name);
}
if (isContractPartiesBidirectional)
{
Assert.That(aParty.Contract, Is.SameAs(c));
}
}
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(3);
}
public virtual void CreateWithEmptyOneToManyCollectionMergeWithExistingElement()
{
ClearCounts();
Contract c = new Contract(null, "gail", "phone");
Party party = new Party("party");
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
s.Persist(c);
s.Persist(party);
t.Commit();
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
c.AddParty(party);
s = OpenSession();
t = s.BeginTransaction();
c = (Contract)s.Merge(c);
t.Commit();
s.Close();
AssertInsertCount(0);
if (CheckUpdateCountsAfterAddingExistingElement())
{
AssertUpdateCount(isContractVersioned && !isContractPartiesInverse ? 1 : 0);
}
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
c = s.CreateCriteria <Contract>().UniqueResult <Contract>();
if (isContractPartiesInverse)
{
Assert.That(c.Parties.Count, Is.EqualTo(0));
s.Delete(party);
}
else
{
Assert.That(c.Parties.Count, Is.EqualTo(1));
party = c.Parties.First();
Assert.That(party.Name, Is.EqualTo("party"));
if (isContractPartiesBidirectional)
{
Assert.That(party.Contract, Is.SameAs(c));
}
}
s.Delete(c);
Assert.That(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0L));
Assert.That(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResult <long>(), Is.EqualTo(0L));
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(2);
}
public virtual async Task OneToManyCollectionOptimisticLockingWithUpdateAsync()
{
ClearCounts();
Contract cOrig = new Contract(null, "gail", "phone");
Party partyOrig = new Party("party");
cOrig.AddParty(partyOrig);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(cOrig));
await(t.CommitAsync());
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
Contract c = await(s.GetAsync <Contract>(cOrig.Id));
Party newParty = new Party("new party");
c.AddParty(newParty);
await(t.CommitAsync());
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
cOrig.RemoveParty(partyOrig);
await(s.UpdateAsync(cOrig));
try
{
await(t.CommitAsync());
Assert.That(isContractVersioned, Is.False);
}
catch (StaleObjectStateException)
{
Assert.That(isContractVersioned, Is.True);
await(t.RollbackAsync());
}
s.Close();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
// If the entity uses a join mapping, DML queries require temp tables.
if (Dialect.SupportsTemporaryTables)
{
await(s.CreateQuery("delete from Party").ExecuteUpdateAsync());
}
else
{
// The current join mapping seems a bit invalid or unsupported.
// The party_contract join table is optional, but its FK is not-nullable. The test removes the contract
// from both parties (explicitly for partyOrig, indirectly by updating cOrig instead of c for newParty),
// and it the appears those parties are no more loadable, failing with a "not-null property references a
// null or transient value NHibernate.Test.Immutable.EntityWithMutableCollection.Party.Contract".
// So we need to "fix" already previously loaded instances before deleting them.
partyOrig.Contract = cOrig;
newParty.Contract = cOrig;
await(s.DeleteAsync(partyOrig));
await(s.DeleteAsync(newParty));
}
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
await(t.CommitAsync());
s.Close();
}
public virtual async Task OneToManyCollectionOptimisticLockingWithMergeAsync()
{
ClearCounts();
Contract cOrig = new Contract(null, "gail", "phone");
Party partyOrig = new Party("party");
cOrig.AddParty(partyOrig);
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
await(s.PersistAsync(cOrig));
await(t.CommitAsync());
s.Close();
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
Contract c = await(s.GetAsync <Contract>(cOrig.Id));
Party newParty = new Party("new party");
c.AddParty(newParty);
await(t.CommitAsync());
s.Close();
AssertInsertCount(1);
AssertUpdateCount(isContractVersioned ? 1 : 0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
cOrig.RemoveParty(partyOrig);
try
{
await(s.MergeAsync(cOrig));
Assert.That(isContractVersioned, Is.False);
}
catch (StaleObjectStateException)
{
Assert.That(isContractVersioned, Is.True);
}
finally
{
await(t.RollbackAsync());
}
s.Close();
s = OpenSession();
t = s.BeginTransaction();
c = await(s.CreateCriteria <Contract>().UniqueResultAsync <Contract>());
await(s.DeleteAsync(c));
Assert.That(await(s.CreateCriteria <Contract>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
Assert.That(await(s.CreateCriteria <Party>().SetProjection(Projections.RowCountInt64()).UniqueResultAsync <long>()), Is.EqualTo(0L));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(3);
}
