Tests handle changes from baa9eb2

alex-kulakov · alex-kulakov · commit 64c4e0645e09 · 2025-11-11T16:03:15.000+05:00
SystemEvents are out of scope of registration lock
diff --git a/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/EntityChangesTest.cs b/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/EntityChangesTest.cs
@@ -29,7 +29,7 @@ public sealed class EntityChangesTest : AutoBuildTest
     private const string TransactionOnCommitted           = nameof(ChangesOnTransactionCommittedEventTest);
     private const string TransactionOnCommittedSystem     = nameof(ChangesOnTransactionCommittedSystemEventTest);
 
-    private const string ExceptionMessageIdentifier = "Events.Persisting";
+    private const string ExceptionMessageIdentifier = "possibility of changes not saved";
 
     protected override DomainConfiguration BuildConfiguration()
     {
@@ -177,7 +177,8 @@ public void ManualPersistOnPersistedSystemEventTest()
         session.SystemEvents.Persisted += ChangeEntityOnPersisted;
         session.SaveChanges();
         session.SystemEvents.Persisted -= ChangeEntityOnPersisted;
-        // exception handled
+
+        Assert.That(session.EntityChangeRegistry.Count, Is.Not.Zero);
       }
 
       using (var session = Domain.OpenSession())
@@ -191,9 +192,7 @@ public void ManualPersistOnPersistedSystemEventTest()
       static void ChangeEntityOnPersisted(object sender, EventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeEntityRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem, 64));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeEntityRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem, 64);
       }
     }
 
@@ -255,7 +254,7 @@ static void ChangeEntityOnPersisting(object sender, EventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnPersistedEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -286,7 +285,7 @@ static void ChangeEntityOnPersisted(object sender, EventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnPersistedSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -311,9 +310,7 @@ public void ChangesOnPersistedSystemEventTest()
       static void ChangeEntityOnPersisted(object sender, EventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeEntityRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem, 44));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeEntityRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem, 44);
       }
     }
 
@@ -375,7 +372,7 @@ static void ChangeEntityOnPrecommitting(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittingEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -406,7 +403,7 @@ static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittingSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -431,13 +428,11 @@ public void ChangesOnTransactionCommittingSystemEventTest()
       static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeEntityRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem, 24));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeEntityRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem, 24);
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittedEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -469,7 +464,7 @@ static void ChangeEntityOnCommitted(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittedSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
diff --git a/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/NonPairedEntitySetChangesTest.cs b/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/NonPairedEntitySetChangesTest.cs
@@ -29,7 +29,7 @@ public sealed class NonPairedEntitySetChangesTest : AutoBuildTest
     private const string TransactionOnCommitted           = nameof(ChangesOnTransactionCommittedEventTest);
     private const string TransactionOnCommittedSystem     = nameof(ChangesOnTransactionCommittedSystemEventTest);
 
-    private const string ExceptionMessageIdentifier = "Events.Persisting";
+    private const string ExceptionMessageIdentifier = "possibility of changes not saved";
 
     protected override DomainConfiguration BuildConfiguration()
     {
@@ -260,7 +260,8 @@ public void ManualPersistOnPersistedSystemEventTest()
         session.SystemEvents.Persisted += ChangeEntityOnPersisted;
         session.SaveChanges();
         session.SystemEvents.Persisted -= ChangeEntityOnPersisted;
-        // exception handled
+
+        Assert.That(session.EntitySetChangeRegistry.Count, Is.Not.Zero);
       }
 
       using (var session = Domain.OpenSession())
@@ -275,9 +276,7 @@ public void ManualPersistOnPersistedSystemEventTest()
       static void ChangeEntityOnPersisted(object sender, EventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeEntitySetRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeEntitySetRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem);
       }
     }
 
@@ -345,7 +344,7 @@ static void ChangeEntityOnPersisting(object sender, EventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnPersistedEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -379,7 +378,7 @@ static void ChangeEntityOnPersisted(object sender, EventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnPersistedSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -407,9 +406,7 @@ public void ChangesOnPersistedSystemEventTest()
       static void ChangeEntityOnPersisted(object sender, EventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeEntitySetRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeEntitySetRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem);
       }
     }
 
@@ -477,7 +474,7 @@ static void ChangeEntityOnPrecommitting(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittingEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -511,7 +508,7 @@ static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittingSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -539,13 +536,11 @@ public void ChangesOnTransactionCommittingSystemEventTest()
       static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeEntitySetRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+          MakeEntitySetRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem);
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittedEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -580,7 +575,7 @@ static void ChangeEntityOnCommitted(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittedSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
diff --git a/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/NonPairedReferenceChangesTest.cs b/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/NonPairedReferenceChangesTest.cs
@@ -29,7 +29,7 @@ public sealed class NonPairedReferenceChangesTest : AutoBuildTest
     private const string TransactionOnCommitted = nameof(ChangesOnTransactionCommittedEventTest);
     private const string TransactionOnCommittedSystem = nameof(ChangesOnTransactionCommittedSystemEventTest);
 
-    private const string ExceptionMessageIdentifier = "Events.Persisting";
+    private const string ExceptionMessageIdentifier = "possibility of changes not saved";
 
     protected override DomainConfiguration BuildConfiguration()
     {
@@ -260,7 +260,6 @@ public void ManualPersistOnPersistedSystemEventTest()
         session.SystemEvents.Persisted += ChangeEntityOnPersisted;
         session.SaveChanges();
         session.SystemEvents.Persisted -= ChangeEntityOnPersisted;
-        // exception handled
       }
 
       using (var session = Domain.OpenSession())
@@ -275,9 +274,7 @@ public void ManualPersistOnPersistedSystemEventTest()
       static void ChangeEntityOnPersisted(object sender, EventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeNonPairedReferenceRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeNonPairedReferenceRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem);
       }
     }
 
@@ -347,7 +344,7 @@ static void ChangeEntityOnPersisting(object sender, EventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnPersistedEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -382,7 +379,7 @@ static void ChangeEntityOnPersisted(object sender, EventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnPersistedSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -411,9 +408,7 @@ public void ChangesOnPersistedSystemEventTest()
       static void ChangeEntityOnPersisted(object sender, EventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeNonPairedReferenceRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeNonPairedReferenceRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem);
       }
     }
 
@@ -483,7 +478,7 @@ static void ChangeEntityOnPrecommitting(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittingEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -518,7 +513,7 @@ static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittingSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -547,13 +542,11 @@ public void ChangesOnTransactionCommittingSystemEventTest()
       static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)
       {
         var eventAccessor = (SessionEventAccessor) sender;
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-          MakeNonPairedReferenceRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem));
-        Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));
+        MakeNonPairedReferenceRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem);
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittedEventTest()
     {
       using (var session = Domain.OpenSession()) {
@@ -589,7 +582,7 @@ static void ChangeEntityOnCommitted(object sender, TransactionEventArgs e)
       }
     }
 
-    [Test(Description = "Data Loss")]
+    [Test]
     public void ChangesOnTransactionCommittedSystemEventTest()
     {
       using (var session = Domain.OpenSession()) {
diff --git a/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/PairedEntitySetChangesTest.cs b/Orm/Xtensive.Orm.Tests/Storage/DataLossOnEventsPrevention/PairedEntitySetChangesTest.cs

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public sealed class EntityChangesTest : AutoBuildTest`
`29`	`29`	`private const string TransactionOnCommitted = nameof(ChangesOnTransactionCommittedEventTest);`
`30`	`30`	`private const string TransactionOnCommittedSystem = nameof(ChangesOnTransactionCommittedSystemEventTest);`
`31`	`31`
`32`		`- private const string ExceptionMessageIdentifier = "Events.Persisting";`
	`32`	`+ private const string ExceptionMessageIdentifier = "possibility of changes not saved";`
`33`	`33`
`34`	`34`	`protected override DomainConfiguration BuildConfiguration()`
`35`	`35`	`{`
`@@ -177,7 +177,8 @@ public void ManualPersistOnPersistedSystemEventTest()`
`177`	`177`	`session.SystemEvents.Persisted += ChangeEntityOnPersisted;`
`178`	`178`	`session.SaveChanges();`
`179`	`179`	`session.SystemEvents.Persisted -= ChangeEntityOnPersisted;`
`180`		`- // exception handled`
	`180`	`+`
	`181`	`+ Assert.That(session.EntityChangeRegistry.Count, Is.Not.Zero);`
`181`	`182`	`}`
`182`	`183`
`183`	`184`	`using (var session = Domain.OpenSession())`
`@@ -191,9 +192,7 @@ public void ManualPersistOnPersistedSystemEventTest()`
`191`	`192`	`static void ChangeEntityOnPersisted(object sender, EventArgs e)`
`192`	`193`	`{`
`193`	`194`	`var eventAccessor = (SessionEventAccessor) sender;`
`194`		`- var ex = Assert.Throws<InvalidOperationException>(() =>`
`195`		`- MakeEntityRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem, 64));`
`196`		`- Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));`
	`195`	`+ MakeEntityRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem, 64);`
`197`	`196`	`}`
`198`	`197`	`}`
`199`	`198`
`@@ -255,7 +254,7 @@ static void ChangeEntityOnPersisting(object sender, EventArgs e)`
`255`	`254`	`}`
`256`	`255`	`}`
`257`	`256`
`258`		`- [Test(Description = "Data Loss")]`
	`257`	`+ [Test]`
`259`	`258`	`public void ChangesOnPersistedEventTest()`
`260`	`259`	`{`
`261`	`260`	`using (var session = Domain.OpenSession()) {`
`@@ -286,7 +285,7 @@ static void ChangeEntityOnPersisted(object sender, EventArgs e)`
`286`	`285`	`}`
`287`	`286`	`}`
`288`	`287`
`289`		`- [Test(Description = "Data Loss")]`
	`288`	`+ [Test]`
`290`	`289`	`public void ChangesOnPersistedSystemEventTest()`
`291`	`290`	`{`
`292`	`291`	`using (var session = Domain.OpenSession()) {`
`@@ -311,9 +310,7 @@ public void ChangesOnPersistedSystemEventTest()`
`311`	`310`	`static void ChangeEntityOnPersisted(object sender, EventArgs e)`
`312`	`311`	`{`
`313`	`312`	`var eventAccessor = (SessionEventAccessor) sender;`
`314`		`- var ex = Assert.Throws<InvalidOperationException>(() =>`
`315`		`- MakeEntityRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem, 44));`
`316`		`- Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));`
	`313`	`+ MakeEntityRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem, 44);`
`317`	`314`	`}`
`318`	`315`	`}`
`319`	`316`
`@@ -375,7 +372,7 @@ static void ChangeEntityOnPrecommitting(object sender, TransactionEventArgs e)`
`375`	`372`	`}`
`376`	`373`	`}`
`377`	`374`
`378`		`- [Test(Description = "Data Loss")]`
	`375`	`+ [Test]`
`379`	`376`	`public void ChangesOnTransactionCommittingEventTest()`
`380`	`377`	`{`
`381`	`378`	`using (var session = Domain.OpenSession()) {`
`@@ -406,7 +403,7 @@ static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)`
`406`	`403`	`}`
`407`	`404`	`}`
`408`	`405`
`409`		`- [Test(Description = "Data Loss")]`
	`406`	`+ [Test]`
`410`	`407`	`public void ChangesOnTransactionCommittingSystemEventTest()`
`411`	`408`	`{`
`412`	`409`	`using (var session = Domain.OpenSession()) {`
`@@ -431,13 +428,11 @@ public void ChangesOnTransactionCommittingSystemEventTest()`
`431`	`428`	`static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)`
`432`	`429`	`{`
`433`	`430`	`var eventAccessor = (SessionEventAccessor) sender;`
`434`		`- var ex = Assert.Throws<InvalidOperationException>(() =>`
`435`		`- MakeEntityRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem, 24));`
`436`		`- Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));`
	`431`	`+ MakeEntityRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem, 24);`
`437`	`432`	`}`
`438`	`433`	`}`
`439`	`434`
`440`		`- [Test(Description = "Data Loss")]`
	`435`	`+ [Test]`
`441`	`436`	`public void ChangesOnTransactionCommittedEventTest()`
`442`	`437`	`{`
`443`	`438`	`using (var session = Domain.OpenSession()) {`
`@@ -469,7 +464,7 @@ static void ChangeEntityOnCommitted(object sender, TransactionEventArgs e)`
`469`	`464`	`}`
`470`	`465`	`}`
`471`	`466`
`472`		`- [Test(Description = "Data Loss")]`
	`467`	`+ [Test]`
`473`	`468`	`public void ChangesOnTransactionCommittedSystemEventTest()`
`474`	`469`	`{`
`475`	`470`	`using (var session = Domain.OpenSession()) {`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public sealed class NonPairedEntitySetChangesTest : AutoBuildTest`
`29`	`29`	`private const string TransactionOnCommitted = nameof(ChangesOnTransactionCommittedEventTest);`
`30`	`30`	`private const string TransactionOnCommittedSystem = nameof(ChangesOnTransactionCommittedSystemEventTest);`
`31`	`31`
`32`		`- private const string ExceptionMessageIdentifier = "Events.Persisting";`
	`32`	`+ private const string ExceptionMessageIdentifier = "possibility of changes not saved";`
`33`	`33`
`34`	`34`	`protected override DomainConfiguration BuildConfiguration()`
`35`	`35`	`{`
`@@ -260,7 +260,8 @@ public void ManualPersistOnPersistedSystemEventTest()`
`260`	`260`	`session.SystemEvents.Persisted += ChangeEntityOnPersisted;`
`261`	`261`	`session.SaveChanges();`
`262`	`262`	`session.SystemEvents.Persisted -= ChangeEntityOnPersisted;`
`263`		`- // exception handled`
	`263`	`+`
	`264`	`+ Assert.That(session.EntitySetChangeRegistry.Count, Is.Not.Zero);`
`264`	`265`	`}`
`265`	`266`
`266`	`267`	`using (var session = Domain.OpenSession())`
`@@ -275,9 +276,7 @@ public void ManualPersistOnPersistedSystemEventTest()`
`275`	`276`	`static void ChangeEntityOnPersisted(object sender, EventArgs e)`
`276`	`277`	`{`
`277`	`278`	`var eventAccessor = (SessionEventAccessor) sender;`
`278`		`- var ex = Assert.Throws<InvalidOperationException>(() =>`
`279`		`- MakeEntitySetRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem));`
`280`		`- Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));`
	`279`	`+ MakeEntitySetRegistryChange(eventAccessor.Session, ManualPersistOnPersistedSystem);`
`281`	`280`	`}`
`282`	`281`	`}`
`283`	`282`
`@@ -345,7 +344,7 @@ static void ChangeEntityOnPersisting(object sender, EventArgs e)`
`345`	`344`	`}`
`346`	`345`	`}`
`347`	`346`
`348`		`- [Test(Description = "Data Loss")]`
	`347`	`+ [Test]`
`349`	`348`	`public void ChangesOnPersistedEventTest()`
`350`	`349`	`{`
`351`	`350`	`using (var session = Domain.OpenSession()) {`
`@@ -379,7 +378,7 @@ static void ChangeEntityOnPersisted(object sender, EventArgs e)`
`379`	`378`	`}`
`380`	`379`	`}`
`381`	`380`
`382`		`- [Test(Description = "Data Loss")]`
	`381`	`+ [Test]`
`383`	`382`	`public void ChangesOnPersistedSystemEventTest()`
`384`	`383`	`{`
`385`	`384`	`using (var session = Domain.OpenSession()) {`
`@@ -407,9 +406,7 @@ public void ChangesOnPersistedSystemEventTest()`
`407`	`406`	`static void ChangeEntityOnPersisted(object sender, EventArgs e)`
`408`	`407`	`{`
`409`	`408`	`var eventAccessor = (SessionEventAccessor) sender;`
`410`		`- var ex = Assert.Throws<InvalidOperationException>(() =>`
`411`		`- MakeEntitySetRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem));`
`412`		`- Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));`
	`409`	`+ MakeEntitySetRegistryChange(eventAccessor.Session, PersistedOnCommittingSystem);`
`413`	`410`	`}`
`414`	`411`	`}`
`415`	`412`
`@@ -477,7 +474,7 @@ static void ChangeEntityOnPrecommitting(object sender, TransactionEventArgs e)`
`477`	`474`	`}`
`478`	`475`	`}`
`479`	`476`
`480`		`- [Test(Description = "Data Loss")]`
	`477`	`+ [Test]`
`481`	`478`	`public void ChangesOnTransactionCommittingEventTest()`
`482`	`479`	`{`
`483`	`480`	`using (var session = Domain.OpenSession()) {`
`@@ -511,7 +508,7 @@ static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)`
`511`	`508`	`}`
`512`	`509`	`}`
`513`	`510`
`514`		`- [Test(Description = "Data Loss")]`
	`511`	`+ [Test]`
`515`	`512`	`public void ChangesOnTransactionCommittingSystemEventTest()`
`516`	`513`	`{`
`517`	`514`	`using (var session = Domain.OpenSession()) {`
`@@ -539,13 +536,11 @@ public void ChangesOnTransactionCommittingSystemEventTest()`
`539`	`536`	`static void ChangeEntityOnCommitting(object sender, TransactionEventArgs e)`
`540`	`537`	`{`
`541`	`538`	`var eventAccessor = (SessionEventAccessor) sender;`
`542`		`- var ex = Assert.Throws<InvalidOperationException>(() =>`
`543`		`- MakeEntitySetRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem));`
`544`		`- Assert.That(ex.Message.Contains(ExceptionMessageIdentifier));`
	`539`	`+ MakeEntitySetRegistryChange(eventAccessor.Session, TransactionOnCommittingSystem);`
`545`	`540`	`}`
`546`	`541`	`}`
`547`	`542`
`548`		`- [Test(Description = "Data Loss")]`
	`543`	`+ [Test]`
`549`	`544`	`public void ChangesOnTransactionCommittedEventTest()`
`550`	`545`	`{`
`551`	`546`	`using (var session = Domain.OpenSession()) {`
`@@ -580,7 +575,7 @@ static void ChangeEntityOnCommitted(object sender, TransactionEventArgs e)`
`580`	`575`	`}`
`581`	`576`	`}`
`582`	`577`
`583`		`- [Test(Description = "Data Loss")]`
	`578`	`+ [Test]`
`584`	`579`	`public void ChangesOnTransactionCommittedSystemEventTest()`
`585`	`580`	`{`
`586`	`581`	`using (var session = Domain.OpenSession()) {`