public async Task Manager_should_delete_old_stats()
{
const int expectedRepeats = 3;
var age = TimeSpan.FromHours(1);
var utcNow = DateTime.UtcNow;
var asyncCountdown = new AsyncCountdown("delete old stats", expectedRepeats);
var asyncCounter = new AsyncCounter();
var monitorSettings = new Mock<IMonitorSettings>();
monitorSettings.Setup(s => s.StatsHistoryMaxAge).Returns(age);
var timeCoordinator = new Mock<ITimeCoordinator>();
timeCoordinator.Setup(c => c.UtcNow).Returns(utcNow);
var endpointMetricsCoordinator = new Mock<IEndpointMetricsForwarderCoordinator>();
var repository = new Mock<IEndpointStatsRepository>();
repository.Setup(r => r.DeleteStatisticsOlderThan(utcNow - age, It.IsAny<int>())).Returns(() =>
{
asyncCountdown.Decrement();
asyncCounter.Increment();
const int deletedItemsCount = 127;
return asyncCounter.Value >= expectedRepeats ? 0 : deletedItemsCount;
});
using (new EndpointStatsManager(repository.Object, monitorSettings.Object, timeCoordinator.Object, endpointMetricsCoordinator.Object))
await asyncCountdown.WaitAsync(MaxTestTime);
await Task.Delay(TimeSpan.FromMilliseconds(500));
//it should stop calling cleanup when there are no more items to be cleaned
Assert.Equal(expectedRepeats, asyncCounter.Value);
}
public AwaitableBuilder <T> WithCountdown(AsyncCountdown countdown)
{
var inner = _task;
_task = async() =>
{
try
{
return(await inner.Invoke());
}
finally
{
countdown.Decrement();
}
};
return(this);
}
public async Task Notifier_should_cancel_health_check_on_dispose()
{
SetupEndpointRegistration(Guid.NewGuid());
SetupHealthCheckInterval(TimeSpan.FromMilliseconds(1));
var notCancelled = false;
var countdown = new AsyncCountdown("healthCheck", 1);
Func<CancellationToken, Task<EndpointHealth>> healthCheck = async token =>
{
countdown.Decrement();
await Task.Delay(TestMaxTime, token);
notCancelled = true;
return new EndpointHealth(HealthStatus.Healthy);
};
using (CreateNotifier(healthCheck))
await countdown.WaitAsync(TestMaxTime);
Assert.False(notCancelled);
}
public async Task Executor_should_immediately_break_the_loop_on_cancelation()
{
var timeCoordinator = new Mock<ITimeCoordinator>();
var countdown = new AsyncCountdown("task", 1);
var taskNotCancelled = false;
using (var executor = ContinuousTaskExecutor<string>.StartExecutor(timeCoordinator.Object))
{
executor.TryRegisterTaskFor("task", async (item, token) =>
{
countdown.Decrement();
await Task.Delay(_testTimeout, token);
taskNotCancelled = true;
});
await countdown.WaitAsync(_testTimeout);
}
Assert.False(taskNotCancelled, "Task was not cancelled");
timeCoordinator.Verify(c => c.Delay(It.IsAny<TimeSpan>(), It.IsAny<CancellationToken>()), Times.Never, "Executor should not trigger any delay");
}
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);
}
