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)));
}
