public async Task Notifier_should_send_faulty_health_to_the_API_if_provided_health_method_returns_null() { var endpointId = Guid.NewGuid(); HealthUpdate lastCaptured = null; var countdown = new AsyncCountdown("update", 5); SetupHealthCheckInterval(TimeSpan.FromMilliseconds(1)); SetupEndpointRegistration(endpointId); _mockClient.Setup(c => c.SendHealthUpdateAsync(endpointId, AuthenticationToken, It.IsAny <HealthUpdate>(), It.IsAny <CancellationToken>())) .Returns((Guid id, string authToken, HealthUpdate upd, CancellationToken token) => _awaitableFactory .Execute(() => lastCaptured = upd) .WithCountdown(countdown) .RunAsync()); using (CreateNotifier(token => Task.FromResult((EndpointHealth)null))) await countdown.WaitAsync(TestMaxTime); Assert.NotNull(lastCaptured); Assert.Equal(HealthStatus.Faulty, lastCaptured.Status); Assert.Equal("Unable to collect health information", lastCaptured.Details["reason"]); Assert.True(lastCaptured.Details["exception"].StartsWith("System.InvalidOperationException: Health information not provided")); Assert.True(lastCaptured.CheckTimeUtc > DateTime.UtcNow.AddMinutes(-1) && lastCaptured.CheckTimeUtc < DateTime.UtcNow.AddMinutes(1)); }
public async Task Monitor_should_check_endpoint_health_with_regular_intervals() { var interval = TimeSpan.FromMilliseconds(200); var healthCounter = new AsyncCountdown("health", 1); var delayCounter = new AsyncCountdown("delay", 1); _mockHealthMonitor.Setup(cfg => cfg.CheckHealthAsync("address", It.IsAny <CancellationToken>())).Returns(() => _awaitableFactory.Return(new HealthInfo(HealthStatus.Healthy)).WithTimeline("health").WithCountdown(healthCounter).RunAsync()); _mockTimeCoordinator.Setup(cfg => cfg.Delay(interval, It.IsAny <CancellationToken>())).Returns(() => _awaitableFactory.Return().WithDelay(interval).WithTimeline("delay").WithCountdown(delayCounter).RunAsync()); _endpointRegistry.TryRegister(CreateEndpointIdentity("address")); using (CreateEndpointMonitor(interval)) await Task.WhenAll(healthCounter.WaitAsync(TestMaxWaitTime), delayCounter.WaitAsync(TestMaxWaitTime)); var results = _awaitableFactory.GetTimeline(); Assert.True(results.Length > 1, "results.Length>1"); var delayTask = results[0]; var healthTask = results[1]; Assert.Equal(delayTask.Tag, "delay"); Assert.Equal(healthTask.Tag, "health"); AssertTimeOrder(delayTask.Started, healthTask.Started, healthTask.Finished, delayTask.Finished); }
public async Task Executor_should_cancel_all_tasks_on_disposal_and_report_all_finished() { var task1NotCancelled = false; var task2NotCancelled = false; var task1 = "task1"; var task2 = "task2"; var task1Ran = new AsyncCountdown(task1, 1); var task2Ran = new AsyncCountdown(task2, 1); var completed = new ConcurrentQueue <string>(); using (var executor = ContinuousTaskExecutor <string> .StartExecutor(Mock.Of <ITimeCoordinator>())) { executor.FinishedTaskFor += item => completed.Enqueue(item); executor.TryRegisterTaskFor(task1, async(item, token) => { task1Ran.Decrement(); await Task.Delay(_testTimeout, token); task1NotCancelled = true; }); executor.TryRegisterTaskFor(task2, async(item, token) => { task2Ran.Decrement(); await Task.Delay(_testTimeout, token); task2NotCancelled = true; }); await task1Ran.WaitAsync(_testTimeout); await task2Ran.WaitAsync(_testTimeout); } Assert.False(task1NotCancelled, "task1NotCancelled"); Assert.False(task2NotCancelled, "task2NotCancelled"); CollectionAssert.AreEquivalent(new[] { task1, task2 }, completed); }
public async Task Notifier_should_send_notifications_within_specified_time_span() { var minimumChecks = 3; var expectedEventTimeline = new List <string>(); for (var i = 0; i < minimumChecks; ++i) { expectedEventTimeline.AddRange(new[] { "updateHealth_start", "delay_start", "update_finish", "update_finish" }); } var countdown = new AsyncCountdown("notifications", minimumChecks); var endpointId = Guid.NewGuid(); var interval = TimeSpan.FromMilliseconds(300); SetupHealthCheckInterval(interval); SetupEndpointRegistration(endpointId); _mockClient .Setup(c => c.SendHealthUpdateAsync(endpointId, AuthenticationToken, It.IsAny <HealthUpdate>(), It.IsAny <CancellationToken>())) .Returns(() => _awaitableFactory.Return().WithDelay(TimeSpan.FromMilliseconds(100)).WithTimeline("updateHealth").WithCountdown(countdown).RunAsync()); _mockTimeCoordinator .Setup(c => c.Delay(interval, It.IsAny <CancellationToken>())) .Returns(() => _awaitableFactory.Return().WithDelay(TimeSpan.FromMilliseconds(50)).WithTimeline("delay").RunAsync()); using (CreateNotifier()) await countdown.WaitAsync(TestMaxTime); var actualEventTimeline = _awaitableFactory.GetOrderedTimelineEvents() .Select(eventName => (eventName == "updateHealth_finish" || eventName == "delay_finish") ? "update_finish" : eventName) .Take(minimumChecks * 4) .ToArray(); Assert.True(expectedEventTimeline.SequenceEqual(actualEventTimeline), $"Expected:\n{string.Join(",", expectedEventTimeline)}\nGot:\n{string.Join(",", actualEventTimeline)}"); }
private Task StartTaskAsync(AsyncCountdown countdown, AsyncCounter counter, CancellationToken token) { return(StartTaskAsync(token, c => c.WithCountdown(countdown).WithCounter(counter))); }