fixing test

Author: bartekwasielak

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_edit_is_resolved_by_retry.cs

@@ -40,12 +40,13 @@ public async Task Should_publish_notification()
                         return false;
                     }
 
-                    if (!ctx.OriginalMessageHandled)
+                    if (!ctx.OriginalMessageHasBeenHandled)
                     {
                         return false;
                     }
 
-                    if (!ctx.EditedAndRetriedMessage)
+                    // second message - edit & retry
+                    if (!ctx.EditedMessageHasBeenSent)
                     {
                         var failedMessagedId = await this.GetOnlyFailedUnresolvedMessageId();
                         if (failedMessagedId == null)
@@ -54,11 +55,11 @@ public async Task Should_publish_notification()
                         }
 
                         ctx.OriginalMessageFailureId = failedMessagedId;
-                        ctx.EditedAndRetriedMessage = true;
+                        ctx.EditedMessageHasBeenSent = true;
 
                         string editedMessage = JsonSerializer.Serialize(new EditResolutionMessage
                         {
-                            HasBeenEdited = true
+                            ThisIsAnEditedMessage = true
                         });
 
                         SingleResult<FailedMessage> failedMessage =
@@ -73,7 +74,13 @@ public async Task Should_publish_notification()
                         return false;
                     }
 
-                    if (!ctx.RetriedMessage)
+                    if (!ctx.EditedAndRetriedMessageHandled)
+                    {
+                        return false;
+                    }
+
+                    // third message - retry
+                    if (!ctx.RetriedMessageHasBeenSent)
                     {
                         var failedMessageIdAfterId = await this.GetOnlyFailedUnresolvedMessageId();
                         if (failedMessageIdAfterId == null)
@@ -82,18 +89,24 @@ public async Task Should_publish_notification()
                         }
 
                         ctx.EditedMessageFailureId = failedMessageIdAfterId;
-                        ctx.RetriedMessage = true;
+                        ctx.RetriedMessageHasBeenSent = true;
+                        ctx.NeedToHandleRetriedMessage = true;
 
                         await this.Post<object>($"/api/errors/{ctx.EditedMessageFailureId}/retry");
                         return false;
                     }
 
-                    if (!ctx.RetriedMessageHandled || ctx.EditedMessageEditOf == null)
+                    if (!ctx.RetriedMessageHandled)
                     {
                         return false;
                     }
 
-                    if (!ctx.EditedAndRetriedMessgaeHandled || !ctx.MessageResolved)
+                    if (ctx.EditedMessageEditOf == null)
+                    {
+                        return false;
+                    }
+
+                    if (!ctx.MessageResolved)
                     {
                         return false;
                     }
@@ -111,18 +124,19 @@ public async Task Should_publish_notification()
 
         public class EditMessageResolutionContext : ScenarioContext
         {
-            public bool OriginalMessageHandled { get; set; }
+            public bool OriginalMessageHasBeenHandled { get; set; }
             public string OriginalMessageFailureId { get; set; }
 
             public string ResolvedMessageId { get; set; }
             public bool MessageResolved { get; set; }
-            public bool EditedAndRetriedMessgaeHandled { get; set; }
+            public bool EditedAndRetriedMessageHandled { get; set; }
             public bool RetriedMessageHandled { get; set; }
             public string EditedMessageFailureId { get; set; }
-            public bool EditedAndRetriedMessage { get; set; }
-            public bool RetriedMessage { get; set; }
+            public bool EditedMessageHasBeenSent { get; set; }
+            public bool RetriedMessageHasBeenSent { get; set; }
             public string EditedMessageEditOf { get; set; }
             public bool ExternalProcessorSubscribed { get; set; }
+            public bool NeedToHandleRetriedMessage { get; set; }
         }
 
         public class MessageReceiver : EndpointConfigurationBuilder
@@ -135,21 +149,22 @@ public class EditMessageResolutionHandler(EditMessageResolutionContext testConte
             {
                 public Task Handle(EditResolutionMessage message, IMessageHandlerContext context)
                 {
-                    if (!message.HasBeenEdited)
+                    // First run - supposed to fail
+                    if (!message.ThisIsAnEditedMessage)
                     {
-                        testContext.OriginalMessageHandled = true;
+                        testContext.OriginalMessageHasBeenHandled = true;
                         throw new SimulatedException();
                     }
 
-                    if (!testContext.RetriedMessage)
+                    // Second run - edit retry - supposed to fail
+                    if (!testContext.NeedToHandleRetriedMessage)
                     {
                         testContext.EditedMessageEditOf = context.MessageHeaders["ServiceControl.EditOf"];
-                        ;
-                        testContext.EditedAndRetriedMessgaeHandled = true;
+                        testContext.EditedAndRetriedMessageHandled = true;
                         throw new SimulatedException();
                     }
 
-
+                    // Last run - normal retry - supposed to succeed
                     testContext.RetriedMessageHandled = true;
                     return Task.CompletedTask;
                 }
@@ -165,7 +180,7 @@ public Task Handle(MessageFailureResolvedByRetry message, IMessageHandlerContext
 
         public class EditResolutionMessage : IMessage
         {
-            public bool HasBeenEdited { get; init; }
+            public bool ThisIsAnEditedMessage { get; init; }
         }
     }
 }

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_reedit_solves_a_failed_msg.cs

@@ -15,7 +15,7 @@ namespace ServiceControl.AcceptanceTests.Recoverability.ExternalIntegration
     class When_a_reedit_solves_a_failed_msg : AcceptanceTest
     {
         [Test]
-        // [Ignore("testing another approach")]
+        [Ignore("testing another approach")]
         public async Task Should_publish_notification()
         {
             CustomConfiguration = config => config.OnEndpointSubscribed<EditMessageResolutionContext>((s, ctx) =>