Separate tests for minimal required for ingestion vs minimal required for UX experience

Author: andreasohlund

…_message_with_missing_metadata_failed.cs …g_failed_message_with_missing_headers.cssrc/ServiceControl.AcceptanceTests/Recoverability/MessageFailures/When_processing_message_with_missing_metadata_failed.cs renamed to src/ServiceControl.AcceptanceTests/Recoverability/MessageFailures/When_ingesting_failed_message_with_missing_headers.cs src/ServiceControl.AcceptanceTests/Recoverability/MessageFailures/When_processing_message_with_missing_metadata_failed.cs renamed to src/ServiceControl.AcceptanceTests/Recoverability/MessageFailures/When_ingesting_failed_message_with_missing_headers.cs

@@ -12,38 +12,44 @@
     using NServiceBus.Transport;
     using NUnit.Framework;
     using ServiceControl.MessageFailures.Api;
-    using Conventions = NServiceBus.AcceptanceTesting.Customization.Conventions;
 
-    class When_processing_message_with_missing_metadata_failed : AcceptanceTest
+    class When_ingesting_failed_message_with_missing_headers : AcceptanceTest
     {
         [Test]
-        public async Task Null_TimeSent_should_not_be_cast_to_DateTimeMin()
+        public async Task TimeSent_should_not_be_casted()
         {
             FailedMessageView failure = null;
 
-            await Define<MyContext>()
-                .WithEndpoint<Failing>()
+            var sentTime = DateTime.Parse("2014-11-11T02:26:58.000462Z");
+
+            await Define<MyContext>(c =>
+                {
+                    c.AddMinimalRequiredHeaders();
+                    c.Headers.Add("NServiceBus.TimeSent", DateTimeOffsetHelper.ToWireFormattedString(sentTime));
+                })
+                .WithEndpoint<FailingEndpoint>()
                 .Done(async c =>
                 {
-                    var result = await this.TryGetSingle<FailedMessageView>("/api/errors/", m => m.Id == c.UniqueMessageId);
+                    var result = await this.TryGet<FailedMessageView>($"/api/errors/last/{c.UniqueMessageId}");
                     failure = result;
-                    return result;
+                    return (c.UniqueMessageId != null) & result;
                 })
                 .Run();
 
             Assert.That(failure, Is.Not.Null);
-            Assert.That(failure.TimeSent, Is.Null);
+            Assert.That(failure.TimeSent, Is.EqualTo(sentTime));
         }
 
         [Test]
-        public async Task TimeSent_should_not_be_casted()
+        public async Task Should_be_ingested_when_minimal_required_headers_is_present()
         {
             FailedMessageView failure = null;
 
-            var sentTime = DateTime.Parse("2014-11-11T02:26:58.000462Z");
-
-            await Define<MyContext>(ctx => ctx.TimeSent = sentTime)
-                .WithEndpoint<Failing>()
+            await Define<MyContext>(c =>
+                {
+                    c.AddMinimalRequiredHeaders();
+                })
+                .WithEndpoint<FailingEndpoint>()
                 .Done(async c =>
                 {
                     var result = await this.TryGet<FailedMessageView>($"/api/errors/last/{c.UniqueMessageId}");
@@ -53,18 +59,28 @@ await Define<MyContext>(ctx => ctx.TimeSent = sentTime)
                 .Run();
 
             Assert.That(failure, Is.Not.Null);
-            Assert.That(failure.TimeSent, Is.EqualTo(sentTime));
+            Assert.That(failure.TimeSent, Is.Null);
         }
 
         [Test]
-        public async Task Should_be_able_to_get_the_message_by_id()
+        public async Task Should_include_headers_required_by_ServicePulse()
         {
             FailedMessageView failure = null;
 
             var testStartTime = DateTime.UtcNow;
 
-            var context = await Define<MyContext>()
-                .WithEndpoint<Failing>()
+            var context = await Define<MyContext>(c =>
+                {
+                    c.AddMinimalRequiredHeaders();
+
+                    // This is needed for ServiceControl to be able to detect both endpoint (via failed q header) and host via the processing machine header
+                    // Missing endpoint or host will case a null ref in ServicePulse
+                    c.Headers[Headers.ProcessingMachine] = "MyMachine";
+
+                    c.Headers["NServiceBus.ExceptionInfo.ExceptionType"] = "SomeExceptionType";
+                    c.Headers["NServiceBus.ExceptionInfo.Message"] = "Some message";
+                })
+                .WithEndpoint<FailingEndpoint>()
                 .Done(async c =>
                 {
                     var result = await this.TryGet<FailedMessageView>($"/api/errors/last/{c.UniqueMessageId}");
@@ -81,48 +97,43 @@ public async Task Should_be_able_to_get_the_message_by_id()
             // ServicePulse assumes that the receiving endpoint name is present
             Assert.That(failure.ReceivingEndpoint, Is.Not.Null);
             Assert.That(failure.ReceivingEndpoint.Name, Is.EqualTo(context.EndpointNameOfReceivingEndpoint));
+            Assert.That(failure.ReceivingEndpoint.Host, Is.EqualTo("MyMachine"));
+
+            // ServicePulse needs both an exception type and description to render the UI in a resonable way
+            Assert.That(failure.Exception.ExceptionType, Is.EqualTo("SomeExceptionType"));
+            Assert.That(failure.Exception.Message, Is.EqualTo("Some message"));
         }
 
-        class Failing : EndpointConfigurationBuilder
+        class MyContext : ScenarioContext
         {
-            public Failing() => EndpointSetup<DefaultServerWithoutAudit>(c => c.Recoverability().Delayed(x => x.NumberOfRetries(0)));
-
-            class SendFailedMessage : DispatchRawMessages<MyContext>
-            {
-                protected override TransportOperations CreateMessage(MyContext context)
-                {
-                    context.EndpointNameOfReceivingEndpoint = Conventions.EndpointNamingConvention(typeof(Failing));
-                    context.MessageId = Guid.NewGuid().ToString();
-                    context.UniqueMessageId = DeterministicGuid.MakeId(context.MessageId, context.EndpointNameOfReceivingEndpoint).ToString();
+            public string MessageId { get; } = Guid.NewGuid().ToString();
 
-                    var headers = new Dictionary<string, string>
-                    {
-                        [Headers.MessageId] = context.MessageId,
-                        ["NServiceBus.FailedQ"] = Conventions.EndpointNamingConvention(typeof(Failing)),
-                        [Headers.ProcessingMachine] = "unknown", // This is needed for endpoint detection to work since "host" is required, endpoint name is detected from the FailedQ header
-                    };
+            public string EndpointNameOfReceivingEndpoint => "MyEndpoint";
 
-                    if (context.TimeSent.HasValue)
-                    {
-                        headers["NServiceBus.TimeSent"] = DateTimeOffsetHelper.ToWireFormattedString(context.TimeSent.Value);
-                    }
+            public string UniqueMessageId => DeterministicGuid.MakeId(MessageId, EndpointNameOfReceivingEndpoint).ToString();
 
-                    var outgoingMessage = new OutgoingMessage(context.MessageId, headers, Array.Empty<byte>());
+            public Dictionary<string, string> Headers { get; } = [];
 
-                    return new TransportOperations(new TransportOperation(outgoingMessage, new UnicastAddressTag("error")));
-                }
+            public void AddMinimalRequiredHeaders()
+            {
+                Headers["NServiceBus.FailedQ"] = EndpointNameOfReceivingEndpoint;
+                Headers[NServiceBus.Headers.MessageId] = MessageId;
             }
         }
 
-        class MyContext : ScenarioContext
+        class FailingEndpoint : EndpointConfigurationBuilder
         {
-            public string MessageId { get; set; }
-
-            public string EndpointNameOfReceivingEndpoint { get; set; }
+            public FailingEndpoint() => EndpointSetup<DefaultServerWithoutAudit>(c => c.Recoverability().Delayed(x => x.NumberOfRetries(0)));
 
-            public string UniqueMessageId { get; set; }
+            class SendFailedMessage : DispatchRawMessages<MyContext>
+            {
+                protected override TransportOperations CreateMessage(MyContext context)
+                {
+                    var outgoingMessage = new OutgoingMessage(context.MessageId, context.Headers, Array.Empty<byte>());
 
-            public DateTime? TimeSent { get; set; }
+                    return new TransportOperations(new TransportOperation(outgoingMessage, new UnicastAddressTag("error")));
+                }
+            }
         }
     }
 }