Fix Persistence.TCK specs (#5849)

Arkatufus · web-flow · commit 5233233c2f44 · 2022-04-18T16:32:02.000-05:00
* DeleteMessagesFailure message should log its failure stack trace

* Make JournalSpec facts overridable

* Make error reporting standardized.
diff --git a/src/contrib/cluster/Akka.Cluster.Sharding/PersistentShard.cs b/src/contrib/cluster/Akka.Cluster.Sharding/PersistentShard.cs
@@ -125,7 +125,7 @@ protected override bool ReceiveCommand(object message)
                     DeleteSnapshots(new SnapshotSelectionCriteria(deleteTo, DateTime.MaxValue, deleteFrom));
                     break;
                 case DeleteMessagesFailure m:
-                    Log.Warning("PersistentShard messages to [{0}] deletion failure: [{1}]", m.ToSequenceNr, m.Cause.Message);
+                    Log.Warning(m.Cause, "PersistentShard messages to [{0}] deletion failure: [{1}]", m.ToSequenceNr, m.Cause.Message);
                     break;
                 case DeleteSnapshotsSuccess m:
                     Log.Debug("PersistentShard snapshots matching [{0}] deleted successfully", m.Criteria);
diff --git a/src/contrib/cluster/Akka.Cluster.Sharding/PersistentShardCoordinator.cs b/src/contrib/cluster/Akka.Cluster.Sharding/PersistentShardCoordinator.cs
@@ -1446,7 +1446,7 @@ private bool HandleSnapshotResult(object message)
                     DeleteSnapshots(new SnapshotSelectionCriteria(m.ToSequenceNr - 1));
                     break;
                 case DeleteMessagesFailure m:
-                    Log.Warning("Persistent messages to {0} deletion failure: {1}", m.ToSequenceNr, m.Cause.Message);
+                    Log.Warning(m.Cause, "Persistent messages to {0} deletion failure: {1}", m.ToSequenceNr, m.Cause.Message);
                     break;
                 case DeleteSnapshotsSuccess m:
                     Log.Debug("Persistent snapshots matching {0} deleted successfully", m.Criteria);
diff --git a/src/core/Akka.Persistence.TCK/Journal/JournalSpec.cs b/src/core/Akka.Persistence.TCK/Journal/JournalSpec.cs
@@ -155,92 +155,92 @@ private AtomicWrite[] WriteMessages(int from, int to, string pid, IActorRef send
         }
 
         [Fact]
-        public void Journal_should_replay_all_messages()
+        public virtual void Journal_should_replay_all_messages()
         {
             Journal.Tell(new ReplayMessages(1, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
             for (int i = 1; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_messages_using_a_lower_sequence_number_bound()
+        public virtual void Journal_should_replay_messages_using_a_lower_sequence_number_bound()
         {
             Journal.Tell(new ReplayMessages(3, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
             for (int i = 3; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_messages_using_an_upper_sequence_number_bound()
+        public virtual void Journal_should_replay_messages_using_an_upper_sequence_number_bound()
         {
             Journal.Tell(new ReplayMessages(1, 3, long.MaxValue, Pid, _receiverProbe.Ref));
             for (int i = 1; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_messages_using_a_count_limit()
+        public virtual void Journal_should_replay_messages_using_a_count_limit()
         {
             Journal.Tell(new ReplayMessages(1, long.MaxValue, 3, Pid, _receiverProbe.Ref));
             for (int i = 1; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound()
+        public virtual void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound()
         {
             Journal.Tell(new ReplayMessages(2, 3, long.MaxValue, Pid, _receiverProbe.Ref));
             for (int i = 2; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound_and_count_limit()
+        public virtual void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound_and_count_limit()
         {
             Journal.Tell(new ReplayMessages(2, 5, 2, Pid, _receiverProbe.Ref));
             for (int i = 2; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_a_single_if_lower_sequence_number_bound_equals_upper_sequence_number_bound()
+        public virtual void Journal_should_replay_a_single_if_lower_sequence_number_bound_equals_upper_sequence_number_bound()
         {
             Journal.Tell(new ReplayMessages(2, 2, long.MaxValue, Pid, _receiverProbe.Ref));
             _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 2));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_replay_a_single_message_if_count_limit_is_equal_one()
+        public virtual void Journal_should_replay_a_single_message_if_count_limit_is_equal_one()
         {
             Journal.Tell(new ReplayMessages(2, 4, 1, Pid, _receiverProbe.Ref));
             _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 2));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_not_replay_messages_if_count_limit_equals_zero()
+        public virtual void Journal_should_not_replay_messages_if_count_limit_equals_zero()
         {
             Journal.Tell(new ReplayMessages(2, 4, 0, Pid, _receiverProbe.Ref));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_not_replay_messages_if_lower_sequence_number_bound_is_greater_than_upper_sequence_number_bound()
+        public virtual void Journal_should_not_replay_messages_if_lower_sequence_number_bound_is_greater_than_upper_sequence_number_bound()
         {
             Journal.Tell(new ReplayMessages(3, 2, long.MaxValue, Pid, _receiverProbe.Ref));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);
         }
 
         [Fact]
-        public void Journal_should_not_replay_messages_if_the_persistent_actor_has_not_yet_written_messages()
+        public virtual void Journal_should_not_replay_messages_if_the_persistent_actor_has_not_yet_written_messages()
         {
             Journal.Tell(new ReplayMessages(0, long.MaxValue, long.MaxValue, "non-existing-pid", _receiverProbe.Ref));
             _receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 0L);
         }
 
         [Fact]
-        public void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()
+        public virtual void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()
         {
             var receiverProbe2 = CreateTestProbe();
             var command = new DeleteMessagesTo(Pid, 3, receiverProbe2.Ref);
@@ -259,7 +259,7 @@ public void Journal_should_not_replay_permanently_deleted_messages_on_range_dele
         }
 
         [Fact]
-        public void Journal_should_not_reset_HighestSequenceNr_after_message_deletion()
+        public virtual void Journal_should_not_reset_HighestSequenceNr_after_message_deletion()
         {
             Journal.Tell(new ReplayMessages(0, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
             for (int i = 1; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
@@ -274,7 +274,7 @@ public void Journal_should_not_reset_HighestSequenceNr_after_message_deletion()
         }
 
         [Fact]
-        public void Journal_should_not_reset_HighestSequenceNr_after_journal_cleanup()
+        public virtual void Journal_should_not_reset_HighestSequenceNr_after_journal_cleanup()
         {
             Journal.Tell(new ReplayMessages(0, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
             for (int i = 1; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));
@@ -288,7 +288,7 @@ public void Journal_should_not_reset_HighestSequenceNr_after_journal_cleanup()
         }
 
         [Fact]
-        public void Journal_should_serialize_events()
+        public virtual void Journal_should_serialize_events()
         {
             if (!SupportsSerialization) return;
 
@@ -340,7 +340,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)
         }
 
         [Fact]
-        public void Journal_optionally_may_reject_non_serializable_events()
+        public virtual void Journal_optionally_may_reject_non_serializable_events()
         {
             if (!SupportsRejectingNonSerializableObjects) return;
 
diff --git a/src/core/Akka.Persistence.TCK/Query/TestActor.cs b/src/core/Akka.Persistence.TCK/Query/TestActor.cs
@@ -64,6 +64,7 @@ protected Receive WhileDeleting(IActorRef originalSender)
                         Stash.UnstashAll();
                         break;
                     case DeleteMessagesFailure failure:
+                        Log.Error(failure.Cause, "Failed to delete messages to sequence number [{0}].", failure.ToSequenceNr);
                         originalSender.Tell($"{failure.ToSequenceNr}-deleted-failed");
                         Become(OnCommand);
                         Stash.UnstashAll();
diff --git a/src/core/Akka.Persistence/Eventsourced.Lifecycle.cs b/src/core/Akka.Persistence/Eventsourced.Lifecycle.cs
@@ -133,7 +133,7 @@ protected override void Unhandled(object message)
                 case DeleteMessagesFailure failure:
                 {
                     if (Log.IsWarningEnabled)
-                        Log.Warning("Failed to DeleteMessages ToSequenceNr [{0}] for PersistenceId [{1}] due to: [{2}: {3}]", failure.ToSequenceNr, PersistenceId, failure.Cause, failure.Cause.Message);
+                        Log.Warning(failure.Cause, "Failed to DeleteMessages ToSequenceNr [{0}] for PersistenceId [{1}] due to: {2}", failure.ToSequenceNr, PersistenceId, failure.Cause.Message);
                     break;
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -155,92 +155,92 @@ private AtomicWrite[] WriteMessages(int from, int to, string pid, IActorRef send`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`[Fact]`
`158`		`- public void Journal_should_replay_all_messages()`
	`158`	`+ public virtual void Journal_should_replay_all_messages()`
`159`	`159`	`{`
`160`	`160`	`Journal.Tell(new ReplayMessages(1, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));`
`161`	`161`	`for (int i = 1; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`162`	`162`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`[Fact]`
`166`		`- public void Journal_should_replay_messages_using_a_lower_sequence_number_bound()`
	`166`	`+ public virtual void Journal_should_replay_messages_using_a_lower_sequence_number_bound()`
`167`	`167`	`{`
`168`	`168`	`Journal.Tell(new ReplayMessages(3, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));`
`169`	`169`	`for (int i = 3; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`170`	`170`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`[Fact]`
`174`		`- public void Journal_should_replay_messages_using_an_upper_sequence_number_bound()`
	`174`	`+ public virtual void Journal_should_replay_messages_using_an_upper_sequence_number_bound()`
`175`	`175`	`{`
`176`	`176`	`Journal.Tell(new ReplayMessages(1, 3, long.MaxValue, Pid, _receiverProbe.Ref));`
`177`	`177`	`for (int i = 1; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`178`	`178`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`[Fact]`
`182`		`- public void Journal_should_replay_messages_using_a_count_limit()`
	`182`	`+ public virtual void Journal_should_replay_messages_using_a_count_limit()`
`183`	`183`	`{`
`184`	`184`	`Journal.Tell(new ReplayMessages(1, long.MaxValue, 3, Pid, _receiverProbe.Ref));`
`185`	`185`	`for (int i = 1; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`186`	`186`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`[Fact]`
`190`		`- public void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound()`
	`190`	`+ public virtual void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound()`
`191`	`191`	`{`
`192`	`192`	`Journal.Tell(new ReplayMessages(2, 3, long.MaxValue, Pid, _receiverProbe.Ref));`
`193`	`193`	`for (int i = 2; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`194`	`194`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`[Fact]`
`198`		`- public void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound_and_count_limit()`
	`198`	`+ public virtual void Journal_should_replay_messages_using_lower_and_upper_sequence_number_bound_and_count_limit()`
`199`	`199`	`{`
`200`	`200`	`Journal.Tell(new ReplayMessages(2, 5, 2, Pid, _receiverProbe.Ref));`
`201`	`201`	`for (int i = 2; i <= 3; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`202`	`202`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`[Fact]`
`206`		`- public void Journal_should_replay_a_single_if_lower_sequence_number_bound_equals_upper_sequence_number_bound()`
	`206`	`+ public virtual void Journal_should_replay_a_single_if_lower_sequence_number_bound_equals_upper_sequence_number_bound()`
`207`	`207`	`{`
`208`	`208`	`Journal.Tell(new ReplayMessages(2, 2, long.MaxValue, Pid, _receiverProbe.Ref));`
`209`	`209`	`_receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 2));`
`210`	`210`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`[Fact]`
`214`		`- public void Journal_should_replay_a_single_message_if_count_limit_is_equal_one()`
	`214`	`+ public virtual void Journal_should_replay_a_single_message_if_count_limit_is_equal_one()`
`215`	`215`	`{`
`216`	`216`	`Journal.Tell(new ReplayMessages(2, 4, 1, Pid, _receiverProbe.Ref));`
`217`	`217`	`_receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 2));`
`218`	`218`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`[Fact]`
`222`		`- public void Journal_should_not_replay_messages_if_count_limit_equals_zero()`
	`222`	`+ public virtual void Journal_should_not_replay_messages_if_count_limit_equals_zero()`
`223`	`223`	`{`
`224`	`224`	`Journal.Tell(new ReplayMessages(2, 4, 0, Pid, _receiverProbe.Ref));`
`225`	`225`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`[Fact]`
`229`		`- public void Journal_should_not_replay_messages_if_lower_sequence_number_bound_is_greater_than_upper_sequence_number_bound()`
	`229`	`+ public virtual void Journal_should_not_replay_messages_if_lower_sequence_number_bound_is_greater_than_upper_sequence_number_bound()`
`230`	`230`	`{`
`231`	`231`	`Journal.Tell(new ReplayMessages(3, 2, long.MaxValue, Pid, _receiverProbe.Ref));`
`232`	`232`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 5L);`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`[Fact]`
`236`		`- public void Journal_should_not_replay_messages_if_the_persistent_actor_has_not_yet_written_messages()`
	`236`	`+ public virtual void Journal_should_not_replay_messages_if_the_persistent_actor_has_not_yet_written_messages()`
`237`	`237`	`{`
`238`	`238`	`Journal.Tell(new ReplayMessages(0, long.MaxValue, long.MaxValue, "non-existing-pid", _receiverProbe.Ref));`
`239`	`239`	`_receiverProbe.ExpectMsg<RecoverySuccess>(m => m.HighestSequenceNr == 0L);`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`[Fact]`
`243`		`- public void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()`
	`243`	`+ public virtual void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()`
`244`	`244`	`{`
`245`	`245`	`var receiverProbe2 = CreateTestProbe();`
`246`	`246`	`var command = new DeleteMessagesTo(Pid, 3, receiverProbe2.Ref);`
`@@ -259,7 +259,7 @@ public void Journal_should_not_replay_permanently_deleted_messages_on_range_dele`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`[Fact]`
`262`		`- public void Journal_should_not_reset_HighestSequenceNr_after_message_deletion()`
	`262`	`+ public virtual void Journal_should_not_reset_HighestSequenceNr_after_message_deletion()`
`263`	`263`	`{`
`264`	`264`	`Journal.Tell(new ReplayMessages(0, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));`
`265`	`265`	`for (int i = 1; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`@@ -274,7 +274,7 @@ public void Journal_should_not_reset_HighestSequenceNr_after_message_deletion()`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`[Fact]`
`277`		`- public void Journal_should_not_reset_HighestSequenceNr_after_journal_cleanup()`
	`277`	`+ public virtual void Journal_should_not_reset_HighestSequenceNr_after_journal_cleanup()`
`278`	`278`	`{`
`279`	`279`	`Journal.Tell(new ReplayMessages(0, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));`
`280`	`280`	`for (int i = 1; i <= 5; i++) _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, i));`
`@@ -288,7 +288,7 @@ public void Journal_should_not_reset_HighestSequenceNr_after_journal_cleanup()`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`[Fact]`
`291`		`- public void Journal_should_serialize_events()`
	`291`	`+ public virtual void Journal_should_serialize_events()`
`292`	`292`	`{`
`293`	`293`	`if (!SupportsSerialization) return;`
`294`	`294`
`@@ -340,7 +340,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`[Fact]`
`343`		`- public void Journal_optionally_may_reject_non_serializable_events()`
	`343`	`+ public virtual void Journal_optionally_may_reject_non_serializable_events()`
`344`	`344`	`{`
`345`	`345`	`if (!SupportsRejectingNonSerializableObjects) return;`
`346`	`346`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ protected override void Unhandled(object message)`
`133`	`133`	`case DeleteMessagesFailure failure:`
`134`	`134`	`{`
`135`	`135`	`if (Log.IsWarningEnabled)`
`136`		`- Log.Warning("Failed to DeleteMessages ToSequenceNr [{0}] for PersistenceId [{1}] due to: [{2}: {3}]", failure.ToSequenceNr, PersistenceId, failure.Cause, failure.Cause.Message);`
	`136`	`+ Log.Warning(failure.Cause, "Failed to DeleteMessages ToSequenceNr [{0}] for PersistenceId [{1}] due to: {2}", failure.ToSequenceNr, PersistenceId, failure.Cause.Message);`
`137`	`137`	`break;`
`138`	`138`	`}`
`139`	`139`	`}`