chore: replace our own TaskHelpers with a more robust impl., adapted …

…from RestSharp/Rebus. We cannot really avoid doing sync over async in some areas, specifically in older .NET SDK's which do not have sync HttpClient API's.

src/MockHttp/Extensions/ResponseBuilderExtensions.cs

@@ -54,7 +54,7 @@ public static IWithContentResult Body(this IWithContent builder, HttpContent htt
 #if NET6_0_OR_GREATER
             using Stream stream = httpContent.ReadAsStream();
 #else
-            using Stream stream = Threading.TaskHelpers.RunSync(httpContent.ReadAsStreamAsync, TimeSpan.FromMinutes(1));
+            using Stream stream = Threading.AsyncHelpers.RunSync(httpContent.ReadAsStreamAsync);
 #endif
             return (IWithContentResult)BufferedStreamBody(builder, stream)
                 .Headers(httpContent.Headers.Select(kvp => new KeyValuePair<string, IEnumerable<string?>>(kvp.Key, kvp.Value)));

src/MockHttp/MockHttpHandler.cs

@@ -147,7 +147,7 @@ public void Verify(Action<RequestMatching> matching, Func<IsSent> times, string?
     /// </remarks>
     public void Verify(Action<RequestMatching> matching, IsSent times, string? because = null)
     {
-        TaskHelpers.RunSync(() => VerifyAsync(matching, times, because), TimeSpan.FromSeconds(30));
+        AsyncHelpers.RunSync(() => VerifyAsync(matching, times, because));
     }
 
     /// <summary>

src/MockHttp/Threading/AsyncHelpers.cs

@@ -0,0 +1,170 @@
+//  Copyright (c) .NET Foundation and Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Adapted from Rebus
+// Adapted from RestSharp (sha: 159c8a79963b):
+// - dispose ManualResetEvent
+// - added DebuggerStepThroughAttribute
+// - suppress SonarCloud lint S927
+
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.ExceptionServices;
+
+namespace MockHttp.Threading;
+
+#pragma warning disable S927
+[DebuggerStepThrough]
+internal static class AsyncHelpers
+{
+    /// <summary>
+    /// Executes a task synchronously on the calling thread by installing a temporary synchronization context that queues continuations
+    /// </summary>
+    /// <param name="task">Callback for asynchronous task to run</param>
+    public static void RunSync(Func<Task> task)
+    {
+        SynchronizationContext? currentContext = SynchronizationContext.Current;
+        using var customContext = new CustomSynchronizationContext(task);
+
+        try
+        {
+            SynchronizationContext.SetSynchronizationContext(customContext);
+            customContext.Run();
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(currentContext);
+        }
+    }
+
+    /// <summary>
+    /// Executes a task synchronously on the calling thread by installing a temporary synchronization context that queues continuations
+    /// </summary>
+    /// <param name="task">Callback for asynchronous task to run</param>
+    /// <typeparam name="T">Return type for the task</typeparam>
+    /// <returns>Return value from the task</returns>
+    public static T RunSync<T>(Func<Task<T>> task)
+    {
+        T result = default!;
+#pragma warning disable CA2007
+        RunSync(async () => { result = await task(); });
+#pragma warning restore CA2007
+        return result;
+    }
+
+    /// <summary>
+    /// Synchronization context that can be "pumped" in order to have it execute continuations posted back to it
+    /// </summary>
+    private sealed class CustomSynchronizationContext : SynchronizationContext, IDisposable
+    {
+        private readonly ConcurrentQueue<Tuple<SendOrPostCallback, object?>> _items = new();
+        private readonly Func<Task> _task;
+        private readonly AutoResetEvent _workItemsWaiting = new(false);
+        private ExceptionDispatchInfo? _caughtException;
+        private bool _done;
+
+        /// <summary>
+        /// Constructor for the custom context
+        /// </summary>
+        /// <param name="task">Task to execute</param>
+        public CustomSynchronizationContext(Func<Task> task)
+        {
+            _task = task ?? throw new ArgumentNullException(nameof(task), "Please remember to pass a Task to be executed");
+        }
+
+        public void Dispose()
+        {
+            _workItemsWaiting.Dispose();
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, dispatches an asynchronous message to a synchronization context.
+        /// </summary>
+        /// <param name="function">Callback function</param>
+        /// <param name="state">Callback state</param>
+        public override void Post(SendOrPostCallback function, object? state)
+        {
+            _items.Enqueue(Tuple.Create(function, state));
+            _workItemsWaiting.Set();
+        }
+
+        /// <summary>
+        /// Enqueues the function to be executed and executes all resulting continuations until it is completely done
+        /// </summary>
+        public void Run()
+        {
+            Post(PostCallback, null);
+
+            while (!_done)
+            {
+                if (_items.TryDequeue(out Tuple<SendOrPostCallback, object?>? task))
+                {
+                    task.Item1(task.Item2);
+                    if (_caughtException is null)
+                    {
+                        continue;
+                    }
+
+                    _caughtException.Throw();
+                }
+                else
+                {
+                    _workItemsWaiting.WaitOne();
+                }
+            }
+
+            return;
+
+            async void PostCallback(object? _)
+            {
+                try
+                {
+                    await _task().ConfigureAwait(false);
+                }
+                catch (Exception exception)
+                {
+                    _caughtException = ExceptionDispatchInfo.Capture(exception);
+                    throw;
+                }
+                finally
+                {
+                    Post(_ => _done = true, null);
+                }
+            }
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, dispatches a synchronous message to a synchronization context.
+        /// </summary>
+        /// <param name="function">Callback function</param>
+        /// <param name="state">Callback state</param>
+        [ExcludeFromCodeCoverage]
+        public override void Send(SendOrPostCallback function, object? state)
+        {
+            throw new NotSupportedException("Cannot send to same thread");
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, creates a copy of the synchronization context. Not needed, so just return ourselves.
+        /// </summary>
+        /// <returns>Copy of the context</returns>
+        [ExcludeFromCodeCoverage]
+        public override SynchronizationContext CreateCopy()
+        {
+            return this;
+        }
+    }
+}
+#pragma warning restore S927