Test rewrite (removing implementation dependency)

Author: bartekwasielak

src/ServiceControl.AcceptanceTests/Recoverability/When_edited_message_fails_to_process.cs

@@ -1,12 +1,13 @@
 namespace ServiceControl.AcceptanceTests.Recoverability
 {
+    using System;
+    using System.Collections.Generic;
     using System.Linq;
     using System.Text.Json;
     using System.Threading.Tasks;
     using AcceptanceTesting;
     using AcceptanceTesting.EndpointTemplates;
     using AcceptanceTests;
-    using Infrastructure;
     using NServiceBus;
     using NServiceBus.AcceptanceTesting;
     using NServiceBus.Settings;
@@ -22,27 +23,40 @@ public async Task A_new_message_failure_is_created()
             var context = await Define<EditMessageFailureContext>()
                 .WithEndpoint<FailingEditedMessageReceiver>(e => e
                     .When(c => c.SendLocal(new FailingMessage()))
-                    .DoNotFailOnErrorMessages())
+                .DoNotFailOnErrorMessages())
                 .Done(async ctx =>
                 {
-                    if (ctx.OriginalMessageFailureId == null)
+                    if (!ctx.OrignalMessageHandled)
                     {
                         return false;
                     }
 
                     if (!ctx.EditedMessage)
                     {
-                        var failedMessage = await this.TryGet<FailedMessage>($"/api/errors/{ctx.OriginalMessageFailureId}");
-                        if (!failedMessage.HasResult)
+                        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;
+                        var editedMessageInternalId = Guid.NewGuid().ToString();
+                        ctx.EditedMessageInternalId = editedMessageInternalId;
                         var editedMessage = JsonSerializer.Serialize(new FailingMessage
                         {
-                            HasBeenEdited = true
+                            HasBeenEdited = true,
+                            MessageInternalId = editedMessageInternalId
                         });
+
+                        var failedMessage = await this.TryGet<FailedMessage>($"/api/errors/{ctx.OriginalMessageFailureId}");
+
                         var editModel = new EditMessageModel
                         {
                             MessageBody = editedMessage,
@@ -53,23 +67,32 @@ public async Task A_new_message_failure_is_created()
                         return false;
                     }
 
-                    if (ctx.EditedMessageFailureId == null)
+                    if (!ctx.EditedMessageHandled)
+                    {
+                        return false;
+                    }
+
+                    var allFailedMessagesAfterEdit = await this.TryGet<IList<FailedMessageView>>($"/api/errors/?status=unresolved");
+                    if (!allFailedMessagesAfterEdit.HasResult)
                     {
                         return false;
                     }
 
-                    var failedEditedMessage = await this.TryGet<FailedMessage>($"/api/errors/{ctx.EditedMessageFailureId}");
-                    if (!failedEditedMessage.HasResult)
+                    if (allFailedMessagesAfterEdit.Item.Count != 1)
                     {
                         return false;
                     }
 
+                    ctx.EditedMessageFailureId = allFailedMessagesAfterEdit.Item.First().Id;
+
                     ctx.OriginalMessageFailure = (await this.TryGet<FailedMessage>($"/api/errors/{ctx.OriginalMessageFailureId}")).Item;
                     ctx.EditedMessageFailure = (await this.TryGet<FailedMessage>($"/api/errors/{ctx.EditedMessageFailureId}")).Item;
                     return true;
                 })
                 .Run();
 
+            var editedMessageBody = JsonSerializer.Deserialize<FailingMessage>(context.EditedMessageFailure.ProcessingAttempts.Last().MessageMetadata["MsgFullText"].ToString());
+
             Assert.Multiple(() =>
             {
                 Assert.That(context.OriginalMessageFailure.Id, Is.Not.EqualTo(context.EditedMessageFailure.Id));
@@ -79,16 +102,21 @@ public async Task A_new_message_failure_is_created()
                 Assert.That(
                     "FailedMessages/" + context.EditedMessageFailure.ProcessingAttempts.Last().Headers["ServiceControl.EditOf"],
                     Is.EqualTo(context.OriginalMessageFailure.Id));
+                Assert.That(editedMessageBody.MessageInternalId, Is.EqualTo(context.EditedMessageInternalId));
             });
         }
 
         class EditMessageFailureContext : ScenarioContext
         {
-            public string OriginalMessageFailureId { get; set; }
+            public bool OrignalMessageHandled { get; set; }
             public bool EditedMessage { get; set; }
-            public string EditedMessageFailureId { get; set; }
+            public bool EditedMessageHandled { get; set; }
             public FailedMessage OriginalMessageFailure { get; set; }
             public FailedMessage EditedMessageFailure { get; set; }
+
+            public string OriginalMessageFailureId { get; set; }
+            public string EditedMessageFailureId { get; set; }
+            public string EditedMessageInternalId { get; set; }
         }
 
         class FailingEditedMessageReceiver : EndpointConfigurationBuilder
@@ -102,11 +130,11 @@ public Task Handle(FailingMessage message, IMessageHandlerContext context)
                 {
                     if (message.HasBeenEdited)
                     {
-                        testContext.EditedMessageFailureId = DeterministicGuid.MakeId(context.MessageId, settings.EndpointName()).ToString();
+                        testContext.EditedMessageHandled = true;
                     }
                     else
                     {
-                        testContext.OriginalMessageFailureId = DeterministicGuid.MakeId(context.MessageId, settings.EndpointName()).ToString();
+                        testContext.OrignalMessageHandled = true;
                     }
 
                     throw new SimulatedException();
@@ -116,7 +144,8 @@ public Task Handle(FailingMessage message, IMessageHandlerContext context)
 
         class FailingMessage : IMessage
         {
-            public bool HasBeenEdited { get; set; }
+            public bool HasBeenEdited { get; init; }
+            public string MessageInternalId { get; init; }
         }
     }
 }

src/ServiceControl.Persistence/Infrastructure/TransportMessageExtensions.cs

@@ -38,9 +38,7 @@ public static string ProcessingEndpointName(this IReadOnlyDictionary<string, str
 
         public static string UniqueId(this IReadOnlyDictionary<string, string> headers)
         {
-            
-            return headers.TryGetValue("ServiceControl.Retry.UniqueMessageId", out var existingUniqueMessageId) && 
-                   headers.ContainsKey("ServiceControl.Retry.EditOf")
+            return headers.TryGetValue("ServiceControl.Retry.UniqueMessageId", out var existingUniqueMessageId) 
                 ? existingUniqueMessageId
                 : DeterministicGuid.MakeId(headers.MessageId(), headers.ProcessingEndpointName()).ToString();
         }