test: remove blocking waits from tests

Author: thomhurst

tests/Paramore.Brighter.AWS.Tests/MessagingGateway/Sqs/Fifo/Reactor/When_throwing_defer_action_respect_redrive.cs

@@ -136,7 +136,7 @@ public async Task When_throwing_defer_action_respect_redrive_async()
         var quitMessage = MessageFactory.CreateQuitMessage(_subscription.RoutingKey);
         _channel.Enqueue(quitMessage);
 
-        Task.WaitAll(task);
+        await task;
 
         await Task.Delay(5000);
 

tests/Paramore.Brighter.AWS.V4.Tests/MessagingGateway/Sqs/Fifo/Reactor/When_throwing_defer_action_respect_redrive.cs

@@ -136,7 +136,7 @@ public async Task When_throwing_defer_action_respect_redrive_async()
         var quitMessage = MessageFactory.CreateQuitMessage(_subscription.RoutingKey);
         _channel.Enqueue(quitMessage);
 
-        Task.WaitAll(task);
+        await task;
 
         await Task.Delay(5000);
 

tests/Paramore.Brighter.Core.Tests/MessageDispatch/Proactor/When_a_handler_throws_dont_ack_action_should_nack_the_message_async.cs

@@ -46,7 +46,7 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Nack_The_Message_A
             // Act: run pump in background
             var task = Task.Factory.StartNew(() => _messagePump.Run(), TaskCreationOptions.LongRunning);
             // Wait for handler to process the message (DontAckAction thrown)
-            var handled = _commandProcessor.WaitForHandle(5000);
+            var handled = await _commandProcessor.WaitForHandleAsync(5000);
             await Assert.That(handled).IsTrue();
             // Send quit to stop the pump after DontAckAction processing
             _channel.Enqueue(MessageFactory.CreateQuitMessage(_routingKey));
@@ -59,4 +59,4 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Nack_The_Message_A
             await Assert.That(_bus.Stream(_routingKey)).IsNotEmpty();
         }
     }
-}
+}

tests/Paramore.Brighter.Core.Tests/MessageDispatch/Proactor/When_a_handler_throws_dont_ack_action_should_not_acknowledge_async.cs

@@ -46,7 +46,7 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Not_Acknowledge_As
             // Act: run the pump in the background
             var task = Task.Factory.StartNew(() => _messagePump.Run(), TaskCreationOptions.LongRunning);
             // Wait for the handler to be invoked (first delivery)
-            await Assert.That(_commandProcessor.WaitForHandle()).IsTrue();
+            await Assert.That(await _commandProcessor.WaitForHandleAsync()).IsTrue();
             await Assert.That(_commandProcessor.SendCount).IsEqualTo(1);
             // Advance time past the ack timeout to trigger requeue of unacknowledged messages.
             // The message was received via InMemoryMessageConsumer.Receive which locks it in _lockedMessages.
@@ -56,7 +56,7 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Not_Acknowledge_As
             // it was removed from _lockedMessages and no requeue occurs.
             _timeProvider.Advance(TimeSpan.FromSeconds(2));
             // Wait for the handler to be invoked again (re-delivery of unacknowledged message)
-            await Assert.That(_commandProcessor.WaitForHandle()).IsTrue();
+            await Assert.That(await _commandProcessor.WaitForHandleAsync()).IsTrue();
             // Assert: handler was called at least twice (original delivery + re-delivery)
             // This proves the message was NOT acknowledged by the DontAckAction handler
             await Assert.That(_commandProcessor.SendCount >= 2).IsTrue();
@@ -66,4 +66,4 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Not_Acknowledge_As
             await Task.WhenAll(task);
         }
     }
-}
+}

tests/Paramore.Brighter.Core.Tests/MessageDispatch/Reactor/When_a_handler_throws_dont_ack_action_should_nack_the_message.cs

@@ -47,7 +47,7 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Nack_The_Message()
             // Act: run pump in background
             var task = Task.Factory.StartNew(() => _messagePump.Run(), TaskCreationOptions.LongRunning);
             // Wait for handler to process the message (DontAckAction thrown)
-            var handled = _commandProcessor.WaitForHandle(5000);
+            var handled = await _commandProcessor.WaitForHandleAsync(5000);
             await Assert.That(handled).IsTrue();
             // Send quit to stop the pump after DontAckAction processing
             _channel.Enqueue(MessageFactory.CreateQuitMessage(_routingKey));
@@ -60,4 +60,4 @@ public async Task When_A_Handler_Throws_DontAck_Action_Should_Nack_The_Message()
             await Assert.That(_bus.Stream(_routingKey)).IsNotEmpty();
         }
     }
-}
+}

tests/Paramore.Brighter.Core.Tests/MessageDispatch/Reactor/When_an_event_handler_throw_a_reject_message_exception.cs

@@ -41,12 +41,12 @@ public MessageDispatchRejectMessageExceptionTests()
     public async Task When_an_event_handler_throw_a_reject_message_exception()
     {
         // Wait for the handler to be invoked before stopping
-        await Assert.That(MyRejectedEventHandler.WaitForHandle()).IsTrue();
+        await Assert.That(await MyRejectedEventHandler.WaitForHandleAsync()).IsTrue();
         await _dispatcher.End();
         await Assert.That(_bus.Stream(_routingKey)).IsEmpty();
         await Assert.That(_bus.Stream(_deadLetterRoutingKey)).IsNotEmpty();
         var message = _bus.Dequeue(_deadLetterRoutingKey);
         var rejectionReason = $"Message rejected reason: {RejectionReason.DeliveryError} Description: {MyRejectedEventHandlerAsync.TestOfRejectionFlow}";
         await Assert.That(message.Header.Bag[Message.RejectionReasonHeaderName]).IsEqualTo(rejectionReason);
     }
-}
+}

tests/Paramore.Brighter.Core.Tests/MessageDispatch/TestDoubles/MyRejectedEventHandler.cs

@@ -1,18 +1,24 @@
-using System.Threading;
+using System;
+using System.Threading.Tasks;
 using Paramore.Brighter.Actions;
 
 namespace Paramore.Brighter.Core.Tests.MessageDispatch.TestDoubles;
 
 public class MyRejectedEventHandler : RequestHandler<MyRejectedEvent>
 {
-    private static readonly ManualResetEventSlim s_handled = new(false);
+    private static TaskCompletionSource<bool> s_handled = NewCompletionSource();
 
-    public static void Reset() => s_handled.Reset();
-    public static bool WaitForHandle(int timeoutMs = 5000) => s_handled.Wait(timeoutMs);
+    public static void Reset() => s_handled = NewCompletionSource();
+
+    public static Task<bool> WaitForHandleAsync(int timeoutMs = 5000) =>
+        s_handled.Task.WaitAsync(TimeSpan.FromMilliseconds(timeoutMs));
+
+    private static TaskCompletionSource<bool> NewCompletionSource() =>
+        new(TaskCreationOptions.RunContinuationsAsynchronously);
 
     public override MyRejectedEvent Handle(MyRejectedEvent myRejectedEvent)
     {
-        s_handled.Set();
+        s_handled.TrySetResult(true);
         throw new RejectMessageAction("Test of rejection flow");
     }
 }

tests/Paramore.Brighter.Core.Tests/MessageDispatch/TestDoubles/SpyCommandProcessor.cs

@@ -103,7 +103,8 @@ public SpyDontAckCommandProcessor()
             PublishCount = 0;
         }
 
-        public bool WaitForHandle(int timeoutMs = 5000) => _handled.Wait(timeoutMs);
+        public async Task<bool> WaitForHandleAsync(int timeoutMs = 5000) =>
+            await _handled.WaitAsync(TimeSpan.FromMilliseconds(timeoutMs));
 
         public override void Send<T>(T command, RequestContext? requestContext = null)
         {

tests/Paramore.Brighter.Core.Tests/Timeout/Test Doubles/MyFailsDueToTimeoutHandler.cs

@@ -23,9 +23,7 @@ THE SOFTWARE. */
 #endregion
 
 using System;
-using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using Paramore.Brighter.Core.Tests.CommandProcessors.TestDoubles;
 using Paramore.Brighter.Policies.Attributes;
 using Paramore.Brighter.Policies.Handlers;
@@ -44,28 +42,16 @@ public override MyCommand Handle(MyCommand myCommand)
                 //already died
                 return base.Handle(myCommand);
             }
-            try
-            {
-                var delay = Task.Delay(1000, ct).ContinueWith(
-                    x =>
-                    {
-                        // done something I should not do, because I should of been cancel
-                        myCommand.WasCancelled = false;
-                    },
-                    ct);
 
-                Task.WaitAll(new[] { delay });
-            }
-            catch (AggregateException e)
+            if (ct.WaitHandle.WaitOne(1000))
             {
-                foreach (var tce in e.InnerExceptions.OfType<TaskCanceledException>())
-                {
-                    myCommand.WasCancelled = true;
-                    myCommand.TaskCompleted = false;
-                    return base.Handle(myCommand);
-                }
+                myCommand.WasCancelled = true;
+                myCommand.TaskCompleted = false;
+                return base.Handle(myCommand);
             }
 
+            // done something I should not do, because I should of been cancel
+            myCommand.WasCancelled = false;
             myCommand.TaskCompleted = true;
             return base.Handle(myCommand);
         }

tests/Paramore.Brighter.Core.Tests/Timeout/Test Doubles/MyPassesTimeoutHandler.cs

@@ -36,7 +36,15 @@ internal sealed class MyPassesTimeoutHandler : RequestHandler<MyCommand>
         public override MyCommand Handle(MyCommand myCommand)
         {
             var ct = (CancellationToken)Context.Bag[TimeoutPolicyHandler<MyCommand>.CONTEXT_BAG_TIMEOUT_CANCELLATION_TOKEN];
-            Task.Delay(100, ct).ContinueWith((antecedent) => { myCommand.TaskCompleted = true; }, ct).Wait(ct);
+            if (!ct.WaitHandle.WaitOne(100))
+            {
+                myCommand.TaskCompleted = true;
+            }
+            else
+            {
+                ct.ThrowIfCancellationRequested();
+            }
+
             return base.Handle(myCommand);
         }
     }