public void PersistThenMergeInSameTxnWithVersion() { ISession s = OpenSession(); ITransaction tx = s.BeginTransaction(); var entity = new VersionedEntity { Id = "test", Name = "test" }; s.Persist(entity); s.Merge(new VersionedEntity { Id = "test", Name = "test-2" }); try { // control operation... s.SaveOrUpdate(new VersionedEntity { Id = "test", Name = "test-3" }); Assert.Fail("saveOrUpdate() should fail here"); } catch (NonUniqueObjectException) { // expected behavior } tx.Commit(); s.Close(); }
public async Task PersistThenMergeInSameTxnWithVersionAsync() { using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { var entity = new VersionedEntity { Id = "test", Name = "test" }; await(s.PersistAsync(entity)); await(s.MergeAsync(new VersionedEntity { Id = "test", Name = "test-2" })); try { // control operation... await(s.SaveOrUpdateAsync(new VersionedEntity { Id = "test", Name = "test-3" })); Assert.Fail("saveOrUpdate() should fail here"); } catch (NonUniqueObjectException) { // expected behavior } await(tx.CommitAsync()); } }
public void NoExtraUpdatesOnMergeVersionedWithCollection() { var parent = new VersionedEntity { Id = "parent", Name = "parent" }; var child = new VersionedEntity { Id = "child", Name = "child" }; using (ISession s = OpenSession()) using (var t = s.BeginTransaction()) { parent.Children.Add(child); child.Parent = parent; s.Persist(parent); t.Commit(); } ClearCounts(); // parent is now detached, but we have made no changes. so attempt to merge it // into this new session; this should cause no updates... VersionedEntity mergedParent; using (var s = OpenSession()) using (var t = s.BeginTransaction()) { mergedParent = (VersionedEntity)s.Merge(parent); t.Commit(); } AssertUpdateCount(0); AssertInsertCount(0); Assert.That(parent.Version, Is.EqualTo(mergedParent.Version), "unexpected parent version increment"); IEnumerator <VersionedEntity> it = mergedParent.Children.GetEnumerator(); it.MoveNext(); VersionedEntity mergedChild = it.Current; Assert.That(child.Version, Is.EqualTo(mergedChild.Version), "unexpected child version increment"); /////////////////////////////////////////////////////////////////////// // as a control measure, now update the node while it is detached and // make sure we get an update as a result... mergedParent.Name = "new name"; mergedParent.Children.Add(new VersionedEntity { Id = "child2", Name = "new child" }); using (var s = OpenSession()) using (var t = s.BeginTransaction()) { parent = (VersionedEntity)s.Merge(mergedParent); t.Commit(); } AssertUpdateCount(1); AssertInsertCount(1); /////////////////////////////////////////////////////////////////////// }
public void MergeStaleVersionFails() { var entity = new VersionedEntity { Id = "entity", Name = "entity" }; using (ISession s = OpenSession()) using (s.BeginTransaction()) { s.Persist(entity); s.Transaction.Commit(); } // make the detached 'entity' reference stale... using (var s = OpenSession()) using (s.BeginTransaction()) { var entity2 = s.Get <VersionedEntity>(entity.Id); entity2.Name = "entity-name"; s.Transaction.Commit(); } // now try to reattch it ISession s2 = null; try { s2 = OpenSession(); s2.BeginTransaction(); s2.Merge(entity); s2.Transaction.Commit(); Assert.Fail("was expecting staleness error"); } catch (StaleObjectStateException) { // expected outcome... } finally { if (s2 != null) { s2.Transaction.Rollback(); s2.Close(); } Cleanup(); } }
public void NoExtraUpdatesOnMergeVersioned() { var entity = new VersionedEntity { Id = "entity", Name = "entity" }; using (ISession s = OpenSession()) using (var t = s.BeginTransaction()) { s.Persist(entity); t.Commit(); } ClearCounts(); // entity is now detached, but we have made no changes. so attempt to merge it // into this new session; this should cause no updates... VersionedEntity mergedEntity; using (var s = OpenSession()) using (var t = s.BeginTransaction()) { mergedEntity = (VersionedEntity)s.Merge(entity); t.Commit(); } AssertUpdateCount(0); AssertInsertCount(0); Assert.That(entity.Version, Is.EqualTo(mergedEntity.Version), "unexpected version increment"); /////////////////////////////////////////////////////////////////////// // as a control measure, now update the node while it is detached and // make sure we get an update as a result... entity.Name = "new name"; using (var s = OpenSession()) using (var t = s.BeginTransaction()) { entity = (VersionedEntity)s.Merge(entity); t.Commit(); } AssertUpdateCount(1); AssertInsertCount(0); /////////////////////////////////////////////////////////////////////// }
public async Task MergeStaleVersionFailsAsync() { var entity = new VersionedEntity { Id = "entity", Name = "entity" }; using (ISession s = OpenSession()) using (var t = s.BeginTransaction()) { await(s.PersistAsync(entity)); await(t.CommitAsync()); } // make the detached 'entity' reference stale... using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var entity2 = await(s.GetAsync <VersionedEntity>(entity.Id)); entity2.Name = "entity-name"; await(t.CommitAsync()); } // now try to reattach it using (var s2 = OpenSession()) using (var t = s2.BeginTransaction()) { try { await(s2.MergeAsync(entity)); await(t.CommitAsync()); Assert.Fail("was expecting staleness error"); } catch (StaleObjectStateException) { // expected outcome... } finally { await(t.RollbackAsync()); s2.Close(); await(CleanupAsync()); } } }
public void PersistThenMergeInSameTxnWithVersion() { ISession s = OpenSession(); ITransaction tx = s.BeginTransaction(); var entity = new VersionedEntity {Id = "test", Name = "test"}; s.Persist(entity); s.Merge(new VersionedEntity {Id = "test", Name = "test-2"}); try { // control operation... s.SaveOrUpdate(new VersionedEntity {Id = "test", Name = "test-3"}); Assert.Fail("saveOrUpdate() should fail here"); } catch (NonUniqueObjectException) { // expected behavior } tx.Commit(); s.Close(); }
public void NoExtraUpdatesOnMergeVersionedWithCollection() { ISession s = OpenSession(); s.BeginTransaction(); var parent = new VersionedEntity {Id = "parent", Name = "parent"}; var child = new VersionedEntity {Id = "child", Name = "child"}; parent.Children.Add(child); child.Parent = parent; s.Persist(parent); s.Transaction.Commit(); s.Close(); ClearCounts(); // parent is now detached, but we have made no changes. so attempt to merge it // into this new session; this should cause no updates... s = OpenSession(); s.BeginTransaction(); var mergedParent = (VersionedEntity) s.Merge(parent); s.Transaction.Commit(); s.Close(); AssertUpdateCount(0); AssertInsertCount(0); Assert.That(parent.Version, Is.EqualTo(mergedParent.Version), "unexpected parent version increment"); IEnumerator<VersionedEntity> it = mergedParent.Children.GetEnumerator(); it.MoveNext(); VersionedEntity mergedChild = it.Current; Assert.That(child.Version, Is.EqualTo(mergedChild.Version), "unexpected child version increment"); /////////////////////////////////////////////////////////////////////// // as a control measure, now update the node while it is detached and // make sure we get an update as a result... mergedParent.Name = "new name"; mergedParent.Children.Add(new VersionedEntity {Id = "child2", Name = "new child"}); s = OpenSession(); s.BeginTransaction(); parent = (VersionedEntity) s.Merge(mergedParent); s.Transaction.Commit(); s.Close(); AssertUpdateCount(1); AssertInsertCount(1); /////////////////////////////////////////////////////////////////////// }
public void NoExtraUpdatesOnMergeVersioned() { ISession s = OpenSession(); s.BeginTransaction(); var entity = new VersionedEntity {Id = "entity", Name = "entity"}; s.Persist(entity); s.Transaction.Commit(); s.Close(); ClearCounts(); // entity is now detached, but we have made no changes. so attempt to merge it // into this new session; this should cause no updates... s = OpenSession(); s.BeginTransaction(); var mergedEntity = (VersionedEntity) s.Merge(entity); s.Transaction.Commit(); s.Close(); AssertUpdateCount(0); AssertInsertCount(0); Assert.That(entity.Version, Is.EqualTo(mergedEntity.Version), "unexpected version increment"); /////////////////////////////////////////////////////////////////////// // as a control measure, now update the node while it is detached and // make sure we get an update as a result... entity.Name = "new name"; s = OpenSession(); s.BeginTransaction(); entity = (VersionedEntity) s.Merge(entity); s.Transaction.Commit(); s.Close(); AssertUpdateCount(1); AssertInsertCount(0); /////////////////////////////////////////////////////////////////////// }
public void MergeStaleVersionFails() { ISession s = OpenSession(); s.BeginTransaction(); var entity = new VersionedEntity {Id = "entity", Name = "entity"}; s.Persist(entity); s.Transaction.Commit(); s.Close(); // make the detached 'entity' reference stale... s = OpenSession(); s.BeginTransaction(); var entity2 = s.Get<VersionedEntity>(entity.Id); entity2.Name = "entity-name"; s.Transaction.Commit(); s.Close(); // now try to reattch it s = OpenSession(); s.BeginTransaction(); try { s.Merge(entity); s.Transaction.Commit(); Assert.Fail("was expecting staleness error"); } catch (StaleObjectStateException) { // expected outcome... } finally { s.Transaction.Rollback(); s.Close(); Cleanup(); } }