fix(unit tests): make all mixed tests to run tasks concurrently for correct checking of the stampede protection

Author: ne4ta

tests/Cachula.Tests/Core/InMemorySingleFlightProtectorTests/InMemorySingleFlightProtector_Mixed_Tests.cs

@@ -11,13 +11,19 @@ public async Task RunAsync_And_RunManyAsync_SameKey_OnlyOneLoaderRuns()
     {
         var protector = new InMemorySingleFlightProtector();
         int loaderCallCount = 0;
-        async Task<int> LoaderSingle() {
+
+        var startGate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        async Task<int> LoaderSingle()
+        {
+            await startGate.Task;
             loaderCallCount++;
             await Task.Delay(30);
             return 42;
         }
         async Task<IDictionary<string, int>> LoaderBatch(IEnumerable<string> keys)
         {
+            await startGate.Task;
             loaderCallCount++;
             await Task.Delay(30);
             return keys.ToDictionary(k => k, _ => 42);
@@ -28,6 +34,8 @@ async Task<IDictionary<string, int>> LoaderBatch(IEnumerable<string> keys)
         var batchTasks = protector.RunManyAsync([key], LoaderBatch);
         var batchTask = batchTasks[key];
 
+        startGate.TrySetResult();
+
         var results = await Task.WhenAll(singleTask, batchTask);
         Assert.Multiple(() =>
         {
@@ -97,15 +105,19 @@ public async Task ManyParallelRunAsync_And_RunManyAsync_MixedOverlap_OnlyOneLoad
         var protector = new InMemorySingleFlightProtector();
         var loaderCallCount = new ConcurrentDictionary<string, int>();
 
+        var startGate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
         async Task<string> LoaderSingle(string key)
         {
+            await startGate.Task;
             loaderCallCount.AddOrUpdate(key, 1, (_, v) => v + 1);
             await Task.Delay(10);
             return key;
         }
 
         async Task<IDictionary<string, string>> LoaderBatch(IEnumerable<string> keys)
         {
+            await startGate.Task;
             foreach (var key in keys)
             {
                 loaderCallCount.AddOrUpdate(key, 1, (_, v) => v + 1);
@@ -126,6 +138,9 @@ async Task<IDictionary<string, string>> LoaderBatch(IEnumerable<string> keys)
         tasks.AddRange(batch1.Values);
         tasks.AddRange(batch2.Values);
         tasks.AddRange(batch3.Values);
+
+        startGate.TrySetResult();
+
         var results = await Task.WhenAll(tasks);
 
         foreach (var key in allKeys)
@@ -144,8 +159,12 @@ public async Task RunManyAsync_MultipleBatchesWithPartialOverlap_OnlyOneLoaderPe
     {
         var protector = new InMemorySingleFlightProtector();
         var loaderCallCount = new ConcurrentDictionary<string, int>();
+
+        var startGate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
         async Task<IDictionary<string, int>> LoaderBatch(IEnumerable<string> keys)
         {
+            await startGate.Task;
             foreach (var key in keys)
             {
                 loaderCallCount.AddOrUpdate(key, 1, (_, v) => v + 1);
@@ -160,6 +179,9 @@ async Task<IDictionary<string, int>> LoaderBatch(IEnumerable<string> keys)
         var batch3 = protector.RunManyAsync(["c", "d", "e"], LoaderBatch);
         var batch4 = protector.RunManyAsync(["e", "f"], LoaderBatch);
         var allTasks = batch1.Values.Concat(batch2.Values).Concat(batch3.Values).Concat(batch4.Values);
+
+        startGate.TrySetResult();
+
         var results = await Task.WhenAll(allTasks);
         foreach (var key in new[] { "a", "b", "c", "d", "e", "f" })
         {