rewrote the resolved by edit & retry test

Author: bartekwasielak

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

@@ -1,96 +1,127 @@
 namespace ServiceControl.AcceptanceTests.Recoverability.ExternalIntegration
 {
-    using System;
     using System.Collections.Generic;
+    using System.Linq;
     using System.Threading.Tasks;
     using AcceptanceTesting;
     using AcceptanceTesting.EndpointTemplates;
     using Contracts;
     using NServiceBus;
     using NServiceBus.AcceptanceTesting;
     using NUnit.Framework;
-    using ServiceBus.Management.Infrastructure.Settings;
     using ServiceControl.MessageFailures;
+    using ServiceControl.MessageFailures.Api;
     using JsonSerializer = System.Text.Json.JsonSerializer;
 
     class When_a_failed_message_is_resolved_by_edit_and_retry : ExternalIntegrationAcceptanceTest
     {
         [Test]
         public async Task Should_publish_notification()
         {
-            CustomConfiguration = config => config.OnEndpointSubscribed<Context>((s, ctx) =>
-            {
-                ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(ExternalProcessor));
-            });
-
-            var context = await Define<Context>()
-                .WithEndpoint<ErrorSender>(b => b.When(session => Task.CompletedTask).DoNotFailOnErrorMessages())
-                .WithEndpoint<ExternalProcessor>(b => b.When(async (bus, c) =>
+            var context = await Define<EditMessageResolutionContext>()
+                .WithEndpoint<EditMessageResolutionReceiver>(b => b.When(async (bus, c) =>
                 {
                     await bus.Subscribe<MessageFailureResolvedByRetry>();
+                }).When(c => c.SendLocal(new EditResolutionMessage())).DoNotFailOnErrorMessages())
+                .Done(async ctx =>
+                {
+                    if (!ctx.OriginalMessageHandled)
+                    {
+                        return false;
+                    }
 
-                    if (c.HasNativePubSubSupport)
+                    if (!ctx.EditedMessage)
                     {
-                        c.ExternalProcessorSubscribed = true;
+                        var allFailedMessages =
+                            await this.TryGet<IList<FailedMessageView>>($"/api/errors/?status=unresolved");
+                        if (!allFailedMessages.HasResult)
+                        {
+                            return false;
+                        }
+
+                        if (allFailedMessages.Item.Count != 1)
+                        {
+                            return false;
+                        }
+
+                        ctx.OriginalMessageFailureId = allFailedMessages.Item.First().Id;
+
+                        ctx.EditedMessage = true;
+                        string editedMessage = JsonSerializer.Serialize(new EditResolutionMessage
+                        {
+                            HasBeenEdited = true
+                        });
+
+                        SingleResult<FailedMessage> failedMessage =
+                            await this.TryGet<FailedMessage>($"/api/errors/{ctx.OriginalMessageFailureId}");
+
+                        var editModel = new EditMessageModel
+                        {
+                            MessageBody = editedMessage,
+                            MessageHeaders = failedMessage.Item.ProcessingAttempts.Last().Headers
+                        };
+                        await this.Post($"/api/edit/{ctx.OriginalMessageFailureId}", editModel);
+                        return false;
                     }
-                }))
-                .Do("WaitUntilErrorsContainsFailedMessage",
-                    async ctx => await this.TryGet<FailedMessage>($"/api/errors/{ctx.FailedMessageId}") != null)
-                .Do("WaitForExternalProcessorToSubscribe",
-                    ctx => Task.FromResult(ctx.ExternalProcessorSubscribed))
-                .Do("EditAndRetry", async ctx =>
-                {
-                    // First retrieve the original failed message to get all its headers
-                    var originalFailedMessageResult = await this.TryGet<FailedMessage>($"/api/errors/{ctx.FailedMessageId}");
-                    var originalFailedMessage = originalFailedMessageResult.Item;
 
-                    // Convert the original headers to Dictionary<string, string> for the edit payload
-                    var originalHeaders = new Dictionary<string, string>();
-                    foreach (var header in originalFailedMessage.ProcessingAttempts[0].Headers)
+                    if (!ctx.EditedMessageHandled)
                     {
-                        originalHeaders[header.Key] = header.Value;
+                        return false;
                     }
 
-                    // Prepare the edit payload with all original headers (locked headers unchanged, others can be modified)
-                    var editPayload = new
+                    if (!ctx.MessageResolved)
                     {
-                        message_body = "{}",  // Empty JSON body for AMessage (ICommand with no properties) 
-                        message_headers = originalHeaders  // Use all original headers to satisfy controller validation
-                    };
+                        return false;
+                    }
 
-                    await this.Post($"/api/edit/{ctx.FailedMessageId}", editPayload);
-                })
-                .Do("EnsureRetried", async ctx =>
-                {
-                    return await this.TryGet<FailedMessage>($"/api/errors/{ctx.FailedMessageId}",
-                        e => e.Status == FailedMessageStatus.Resolved);
-                })
-                .Done(ctx => ctx.EventDelivered) //Done when sequence is finished
-                .Run();
-
-            var deserializedEvent = JsonSerializer.Deserialize<MessageFailureResolvedByRetry>(context.Event);
-            Assert.That(deserializedEvent?.FailedMessageId, Is.EqualTo(context.FailedMessageId.ToString()));
+                    return true;
+                }).Run();
+
+            Assert.That(context.ResolvedMessageId, Is.EqualTo(context.OriginalMessageFailureId));
         }
 
-        public class ExternalProcessor : EndpointConfigurationBuilder
+
+        class EditMessageResolutionContext : ScenarioContext
         {
-            public ExternalProcessor() =>
-                EndpointSetup<DefaultServerWithoutAudit>(c =>
-                {
-                    var routing = c.ConfigureRouting();
-                    routing.RouteToEndpoint(typeof(MessageFailureResolvedByRetry).Assembly, Settings.DEFAULT_INSTANCE_NAME);
-                }, publisherMetadata => { publisherMetadata.RegisterPublisherFor<MessageFailureResolvedByRetry>(Settings.DEFAULT_INSTANCE_NAME); });
+            public bool OriginalMessageHandled { get; set; }
+            public bool EditedMessage { get; set; }
+            public string OriginalMessageFailureId { get; set; }
+            public bool EditedMessageHandled { get; set; }
+            public string ResolvedMessageId { get; set; }
+            public bool MessageResolved { get; set; }
+        }
 
-            public class FailureHandler(Context testContext) : IHandleMessages<MessageFailureResolvedByRetry>
+        class EditMessageResolutionReceiver : EndpointConfigurationBuilder
+        {
+            public EditMessageResolutionReceiver() => EndpointSetup<DefaultServerWithoutAudit>(c => c.NoRetries());
+
+            class EditMessageResolutionHandler(EditMessageResolutionContext testContext)
+                : IHandleMessages<EditResolutionMessage>, IHandleMessages<MessageFailureResolvedByRetry>
             {
+                public Task Handle(EditResolutionMessage message, IMessageHandlerContext context)
+                {
+                    if (message.HasBeenEdited)
+                    {
+                        testContext.EditedMessageHandled = true;
+                        return Task.CompletedTask;
+                    }
+
+                    testContext.OriginalMessageHandled = true;
+                    throw new SimulatedException();
+                }
+
                 public Task Handle(MessageFailureResolvedByRetry message, IMessageHandlerContext context)
                 {
-                    var serializedMessage = JsonSerializer.Serialize(message);
-                    testContext.Event = serializedMessage;
-                    testContext.EventDelivered = true;
+                    testContext.ResolvedMessageId = message.FailedMessageId;
+                    testContext.MessageResolved = true;
                     return Task.CompletedTask;
                 }
             }
         }
+
+        class EditResolutionMessage : IMessage
+        {
+            public bool HasBeenEdited { get; init; }
+        }
     }
-}
+}