Make ConcurrentJobConfigurationShouldBeRespected a little less flaky

Fix #167

tests/NCronJob.Tests/NCronJobIntegrationTests.cs

@@ -348,15 +348,29 @@ public async Task ConcurrentJobConfigurationShouldBeRespected()
             .And.WithCronExpression("* * * * *").WithName("Job 2")
             .And.WithCronExpression("* * * * *").WithName("Job 3")
             .And.WithCronExpression("* * * * *").WithName("Job 4")));
+
         var provider = CreateServiceProvider();
 
+        (IDisposable subscriber, IList<ExecutionProgress> events) = RegisterAnExecutionProgressSubscriber(provider);
+
         await provider.GetRequiredService<IHostedService>().StartAsync(CancellationToken);
 
         FakeTimer.Advance(TimeSpan.FromMinutes(1));
-        // Wait 2 instances at the same time
-        (await WaitForJobsOrTimeout(2, TimeSpan.FromMilliseconds(150))).ShouldBeTrue();
-        // But not another instance
-        (await WaitForJobsOrTimeout(1, TimeSpan.FromMilliseconds(50))).ShouldBeFalse();
+
+        await WaitUntilConditionIsMet(events, AtLeastTwoJobsAreInitializing);
+
+        subscriber.Dispose();
+
+        var runningJobs = events.Where(e => e.State == ExecutionState.Initializing).ToList();
+
+        Assert.Equal(2, runningJobs.Count);
+        Assert.NotEqual(runningJobs[0].CorrelationId, runningJobs[1].CorrelationId);
+
+        bool AtLeastTwoJobsAreInitializing(IList<ExecutionProgress> events)
+        {
+            var jobs = events.Where(e => e.State == ExecutionState.Initializing).ToList();
+            return jobs.Count >= 2;
+        }
     }
 
     [Fact]

tests/NCronJob.Tests/TestHelper.cs

@@ -4,6 +4,7 @@
 using System.Threading.Channels;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Time.Testing;
 using Shouldly;
 
@@ -108,9 +109,9 @@ protected IEnumerable<Task> GetCompletionJobs(int expectedJobCount, Cancellation
         }
     }
 
-    protected static async Task WaitForOrchestrationCompletion(
+    protected async Task WaitUntilConditionIsMet(
         IList<ExecutionProgress> events,
-        Guid orchestrationId)
+        Func<IList<ExecutionProgress>, bool> evaluator)
     {
         // Note: Although this function could seem a bit over-engineered, it's sadly necessary. 
         // Indeed, events may actually be updated upstream while it's being enumerated
@@ -119,26 +120,41 @@ protected static async Task WaitForOrchestrationCompletion(
 
         int index = 0;
 
+        List<ExecutionProgress> tmp = [];
+
         while (true)
         {
             int count = events.Count;
 
             while (index < count)
             {
-                ExecutionProgress @event = events[index];
-
-                if (@event.CorrelationId == orchestrationId && @event.State == ExecutionState.OrchestrationCompleted)
-                {
-                    return;
-                }
-
+                tmp.Add(events[index]);
                 index++;
             }
 
-            await Task.Delay(TimeSpan.FromMicroseconds(100));
+            if (evaluator(tmp))
+            {
+                return;
+            }
+
+            await Task.Delay(TimeSpan.FromMicroseconds(10), CancellationToken);
         }
     }
 
+    protected async Task WaitForOrchestrationCompletion(
+        IList<ExecutionProgress> events,
+        Guid orchestrationId)
+    {
+        await WaitUntilConditionIsMet(events, OrchestrationIsCompleted);
+
+        bool OrchestrationIsCompleted(IList<ExecutionProgress> events)
+        {
+            return events.Any(@event =>
+                @event.CorrelationId == orchestrationId &&
+                @event.State == ExecutionState.OrchestrationCompleted);
+        };
+    }
+
     protected static (IDisposable subscriber, IList<ExecutionProgress> events) RegisterAnExecutionProgressSubscriber(IServiceProvider serviceProvider)
     {
         SynchronizedCollection<ExecutionProgress> events = [];