Convert to new style of acceptance tests

Author: andreasohlund

src/NServiceBus.AcceptanceTests/Core/OpenTelemetry/When_incoming_message_handled.cs

@@ -14,20 +14,25 @@ public class When_incoming_message_handled : NServiceBusAcceptanceTest
 {
     static readonly string HandlerTimeMetricName = "nservicebus.messaging.handler_time";
     static readonly string CriticalTimeMetricName = "nservicebus.messaging.critical_time";
+    const int NumberOfMessages = 5;
 
     [Test]
     public async Task Should_record_critical_time()
     {
-        using var metricsListener = await WhenMessagesHandled(() => new MyMessage());
-        metricsListener.AssertMetric(CriticalTimeMetricName, 5);
+        using var metricsListener = TestingMetricListener.SetupNServiceBusMetricsListener();
+
+        await WhenMessagesHandled(() => new MyMessage());
+        metricsListener.AssertMetric(CriticalTimeMetricName, NumberOfMessages);
         AssertMandatoryTags(metricsListener, CriticalTimeMetricName, typeof(MyMessage));
     }
 
     [Test]
     public async Task Should_record_success_handling_time()
     {
-        using var metricsListener = await WhenMessagesHandled(() => new MyMessage());
-        metricsListener.AssertMetric(HandlerTimeMetricName, 5);
+        using var metricsListener = TestingMetricListener.SetupNServiceBusMetricsListener();
+
+        await WhenMessagesHandled(() => new MyMessage());
+        metricsListener.AssertMetric(HandlerTimeMetricName, NumberOfMessages);
         AssertMandatoryTags(metricsListener, HandlerTimeMetricName, typeof(MyMessage));
         var handlerType = metricsListener.AssertTagKeyExists(HandlerTimeMetricName, "nservicebus.message_handler_type");
         Assert.That(handlerType, Is.EqualTo(typeof(MyMessageHandler).FullName));
@@ -38,8 +43,10 @@ public async Task Should_record_success_handling_time()
     [Test]
     public async Task Should_record_failure_handling_time()
     {
-        using var metricsListener = await WhenMessagesHandled(() => new MyExceptionalMessage());
-        metricsListener.AssertMetric(HandlerTimeMetricName, 5);
+        using var metricsListener = TestingMetricListener.SetupNServiceBusMetricsListener();
+
+        await WhenMessagesHandled(() => new MyExceptionalMessage());
+        metricsListener.AssertMetric(HandlerTimeMetricName, NumberOfMessages);
         AssertMandatoryTags(metricsListener, HandlerTimeMetricName, typeof(MyExceptionalMessage));
         var handlerType = metricsListener.AssertTagKeyExists(HandlerTimeMetricName, "nservicebus.message_handler_type");
         Assert.That(handlerType, Is.EqualTo(typeof(MyExceptionalHandler).FullName));
@@ -52,46 +59,24 @@ public async Task Should_record_failure_handling_time()
     [Test]
     public async Task Should_not_record_critical_time_on_failure()
     {
-        using var metricsListener = await WhenMessagesHandled(() => new MyExceptionalMessage());
+        using var metricsListener = TestingMetricListener.SetupNServiceBusMetricsListener();
+        await WhenMessagesHandled(() => new MyExceptionalMessage());
         metricsListener.AssertMetric(CriticalTimeMetricName, 0);
     }
 
-    static async Task<TestingMetricListener> WhenMessagesHandled(Func<IMessage> messageFactory)
-    {
-        TestingMetricListener metricsListener = null;
-        try
-        {
-            metricsListener = TestingMetricListener.SetupNServiceBusMetricsListener();
-
-            _ = await Scenario.Define<Context>()
-                .WithEndpoint<EndpointWithMetrics>(b =>
-                    b.DoNotFailOnErrorMessages()
-                        .CustomConfig(c => c.MakeInstanceUniquelyAddressable("discriminator"))
-                        .When(async (session, _) =>
+    static Task WhenMessagesHandled(Func<IMessage> messageFactory) =>
+        Scenario.Define<Context>()
+            .WithEndpoint<EndpointWithMetrics>(b =>
+                b.DoNotFailOnErrorMessages()
+                    .CustomConfig(c => c.MakeInstanceUniquelyAddressable("discriminator"))
+                    .When(async session =>
+                    {
+                        for (var x = 0; x < NumberOfMessages; x++)
                         {
-                            for (var x = 0; x < 5; x++)
-                            {
-                                try
-                                {
-                                    await session.SendLocal(messageFactory.Invoke());
-                                }
-                                catch (Exception e)
-                                {
-                                    Console.WriteLine(e);
-                                }
-                            }
-                        }))
-                .Done(c => c.TotalHandledMessages == 5)
-                .Run();
-            return metricsListener;
-        }
-        catch
-        {
-            metricsListener?.Dispose();
-            throw;
-        }
-    }
-
+                            await session.SendLocal(messageFactory.Invoke());
+                        }
+                    }))
+            .Run();
 
     static void AssertMandatoryTags(
         TestingMetricListener metricsListener,
@@ -108,7 +93,9 @@ static void AssertMandatoryTags(
 
     class Context : ScenarioContext
     {
-        public int TotalHandledMessages;
+        public void MaybeCompleted() => MarkAsCompleted(Interlocked.Increment(ref TotalHandledMessages) == NumberOfMessages);
+
+        int TotalHandledMessages;
     }
 
     class EndpointWithMetrics : EndpointConfigurationBuilder
@@ -120,7 +107,7 @@ class MyMessageHandler(Context testContext) : IHandleMessages<MyMessage>
     {
         public Task Handle(MyMessage message, IMessageHandlerContext context)
         {
-            Interlocked.Increment(ref testContext.TotalHandledMessages);
+            testContext.MaybeCompleted();
             return Task.CompletedTask;
         }
     }
@@ -129,7 +116,7 @@ class MyExceptionalHandler(Context testContext) : IHandleMessages<MyExceptionalM
     {
         public Task Handle(MyExceptionalMessage message, IMessageHandlerContext context)
         {
-            Interlocked.Increment(ref testContext.TotalHandledMessages);
+            testContext.MaybeCompleted();
             throw new Exception();
         }
     }

src/NServiceBus.AcceptanceTests/Core/OpenTelemetry/When_incoming_message_handled_successfully.cs

@@ -11,21 +11,22 @@
 [NonParallelizable]
 public class WhenIncomingMessageHandledSuccessfully : NServiceBusAcceptanceTest
 {
+    const int NumberOfMessages = 5;
+
     [Test]
     public async Task Should_record_handling_time()
     {
         using var metricsListener = TestingMetricListener.SetupNServiceBusMetricsListener();
 
         _ = await Scenario.Define<Context>()
             .WithEndpoint<EndpointWithMetrics>(b =>
-                b.When(async (session, _) =>
+                b.When(async session =>
                 {
-                    for (var x = 0; x < 5; x++)
+                    for (var x = 0; x < NumberOfMessages; x++)
                     {
                         await session.SendLocal(new MyMessage());
                     }
                 }))
-            .Done(c => c.TotalHandledMessages == 5)
             .Run();
 
         string handlingTime = "nservicebus.messaging.handler_time";
@@ -40,7 +41,9 @@ public async Task Should_record_handling_time()
 
     class Context : ScenarioContext
     {
-        public int TotalHandledMessages;
+        public void MaybeCompleted() => MarkAsCompleted(Interlocked.Increment(ref TotalHandledMessages) == NumberOfMessages);
+
+        int TotalHandledMessages;
     }
 
     class EndpointWithMetrics : EndpointConfigurationBuilder
@@ -52,7 +55,7 @@ class MyMessageHandler(Context testContext) : IHandleMessages<MyMessage>
     {
         public Task Handle(MyMessage message, IMessageHandlerContext context)
         {
-            Interlocked.Increment(ref testContext.TotalHandledMessages);
+            testContext.MaybeCompleted();
             return Task.CompletedTask;
         }
     }