void TestTxtJson()
{
var managedTasks = new ManagedTasks.ManagedTasks();
managedTasks.OnProgress += Progress;
var progressTask = new ProgressTask(20, 5);
var task1 = managedTasks.Add("123", "task", "test", progressTask, null);
var serialized = System.Text.Json.JsonSerializer.Serialize(task1);
var newTask = System.Text.Json.JsonSerializer.Deserialize <ManagedTask>(serialized);
Assert.Equal(task1.OriginatorId, newTask.OriginatorId);
}
void Test_MessagePack()
{
var managedTasks = new ManagedTasks.ManagedTasks();
managedTasks.OnProgress += Progress;
var progressTask = new ProgressTask(20, 5);
var task1 = managedTasks.Add("123", "task", "test", progressTask, null);
var serialized = MessagePackSerializer.Serialize(task1);
var newTask = MessagePackSerializer.Deserialize <ManagedTask>(serialized);
Assert.Equal(task1.OriginatorId, newTask.OriginatorId);
}
void Test_NewtonSoftJson()
{
var managedTasks = new ManagedTasks.ManagedTasks();
managedTasks.OnProgress += Progress;
var progressTask = new ProgressTask(20, 5);
var task1 = managedTasks.Add("123", "task", "test", progressTask, null);
var serialized = JsonConvert.SerializeObject(task1);
var newTask = JsonConvert.DeserializeObject <ManagedTask>(serialized);
Assert.Equal(task1.OriginatorId, newTask.OriginatorId);
}
public void Test_ManagedTask_BadTrigger()
{
var managedTasks = new ManagedTasks.ManagedTasks();
var trigger = new ManagedTaskTrigger(TimeSpan.Zero, 5);
var triggers = new[] { trigger };
var progressTask = new ProgressTask(200, 5);
Assert.Throws <ManagedTaskTriggerException>(() =>
{
var managedTask = managedTasks.Add("123", "task", "test", "category", 1, "id", 1, progressTask,
triggers, null, null);
});
Assert.Empty(managedTasks.GetActiveTasks());
}
public async Task Test_ManagedTask_Schedule_RecurringAsync()
{
var managedTasks = new ManagedTasks.ManagedTasks();
var startTime = DateTime.Now.TimeOfDay;
// simple task that takes 1 second to run
var managedObject = new ProgressTask(1000, 1);
var scheduleCount = 0;
void OnSchedule(object sender, EManagedTaskStatus status)
{
if (status == EManagedTaskStatus.Scheduled)
{
Interlocked.Increment(ref scheduleCount);
}
}
managedTasks.OnStatus += OnSchedule;
// starts in 1 second, then runs 1 second job
var trigger = new ManagedTaskTrigger()
{
StartDate = DateTime.Now,
StartTime = DateTime.Now.AddSeconds(1).TimeOfDay,
IntervalTime = TimeSpan.FromSeconds(2),
MaxRecurs = 5
};
managedTasks.Add("123", "task3", "test", managedObject, new[] { trigger });
var cts = new CancellationTokenSource();
cts.CancelAfter(30000);
await managedTasks.WhenAll(cts.Token);
Assert.Equal(5, scheduleCount);
Assert.Equal(0, managedTasks.RunningCount);
Assert.Equal(0, managedTasks.ScheduledCount);
Assert.Equal(5, managedTasks.CompletedCount);
// 10 seconds = Initial 1 + 2 *(5-1) recurs + 1 final job
Assert.True(trigger.StartDate.Value.AddSeconds(10) <= DateTime.Now);
}
// test a scheduled task is added to the queue, and removed when cancelled.
public async Task Test_ManagedTask_Schedule_Recurring_CancelAsync()
{
var managedTasks = new ManagedTasks.ManagedTasks();
// simple task that takes 1 second to run
var managedObject = new ProgressTask(1000, 1);
var scheduleCount = 0;
void OnSchedule(object sender, EManagedTaskStatus status)
{
if (status == EManagedTaskStatus.Scheduled)
{
Interlocked.Increment(ref scheduleCount);
}
}
managedTasks.OnStatus += OnSchedule;
// starts in 1 second, then runs 1 second job
var trigger = new ManagedTaskTrigger()
{
StartDate = DateTime.Now,
StartTime = DateTime.Now.AddSeconds(100).TimeOfDay,
IntervalTime = TimeSpan.FromSeconds(2),
MaxRecurs = 5
};
var task = managedTasks.Add("123", "task3", "test", managedObject, new[] { trigger });
Assert.Single(managedTasks.GetScheduledTasks());
await Task.Delay(2000, CancellationToken.None);
task.Cancel();
await Task.Delay(100, CancellationToken.None); //small delay to give spooler a chance to remove task from schedule.
Assert.Empty(managedTasks.GetScheduledTasks());
}
public async Task Test_ManagedTask_Schedule_Error_No_IntervalTime()
{
var managedTasks = new ManagedTasks.ManagedTasks();
var startTime = DateTime.Now.TimeOfDay;
// simple task that takes 1 second to run
var managedObject = new ProgressTask(1000, 1);
var scheduleCount = 0;
void OnSchedule(object sender, EManagedTaskStatus status)
{
if (status == EManagedTaskStatus.Scheduled)
{
Interlocked.Increment(ref scheduleCount);
}
}
managedTasks.OnStatus += OnSchedule;
// starts in 1 second, then runs 1 second job
var trigger = new ManagedTaskTrigger()
{
StartDate = DateTime.Now,
StartTime = DateTime.Now.AddSeconds(1).TimeOfDay,
IntervalTime = TimeSpan.FromSeconds(0),
MaxRecurs = null,
IntervalType = EIntervalType.Interval
};
managedTasks.Add("123", "task3", "test", managedObject, new[] { trigger });
var cts = new CancellationTokenSource();
cts.CancelAfter(30000);
Assert.ThrowsAsync <ManagedTaskTriggerException>(async() => await managedTasks.WhenAll(cts.Token));
}
public async Task Test_ManagedTask_Dependencies_ChainAsync()
{
var managedTasks = new ManagedTasks.ManagedTasks();
// simple task that takes 5 seconds
var managedObject = new ProgressTask(5000, 1);
var timer = Stopwatch.StartNew();
// run task1, then task2, then task 3
var task1 = managedTasks.Add("123", "task1", "test", managedObject, null);
var task2 = managedTasks.Add("123", "task2", "test", managedObject, null, new[] { task1.TaskId });
var task3 = managedTasks.Add("123", "task3", "test", managedObject, null, new[] { task2.TaskId });
var cts = new CancellationTokenSource();
cts.CancelAfter(30000);
await managedTasks.WhenAll(cts.Token);
// job should take 15 seconds.
Assert.True(timer.Elapsed.Seconds >= 15 && timer.Elapsed.Seconds <= 16, $"Took {timer.Elapsed.Seconds} should take 15 seconds.");
}
public async Task Test_ManagedTasks_WithKeysAsync()
{
var managedTasks = new ManagedTasks.ManagedTasks();
var progressTask = new ProgressTask(200, 5);
managedTasks.Add("123", "task", "test", "category", 1, "id", 1, progressTask, null, null, null);
//adding the same task when running should result in error.
Assert.Throws <ManagedTaskException>(() =>
{
managedTasks.Add("123", "task", "test", "category", 1, "id", 1, progressTask, null, null, null);
});
var cts = new CancellationTokenSource();
cts.CancelAfter(30000);
await managedTasks.WhenAll(cts.Token);
// add the same task again now the previous one has finished.
managedTasks.Add("123", "task", "test", "category", 1, "id", 1, progressTask, null, null, null);
Assert.Single(managedTasks.GetCompletedTasks());
}
public async Task Test_MultipleManagedTasksAsync(int taskCount)
{
var completedCounter = 0;
var runningCounter = 0;
void CompletedCounter(object sender, EManagedTaskStatus status)
{
switch (status)
{
case EManagedTaskStatus.Running:
Interlocked.Increment(ref runningCounter);
break;
case EManagedTaskStatus.Error:
var t = (ManagedTask)sender;
_output.WriteLine("Error status: " + status + ". Error: " + t?.Exception?.Message);
break;
case EManagedTaskStatus.Completed:
Interlocked.Increment(ref completedCounter);
if (completedCounter == taskCount)
{
_output.WriteLine("complete success");
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(status), status, null);
}
}
var managedTasks = new ManagedTasks.ManagedTasks();
managedTasks.OnStatus += CompletedCounter;
var managedObject = new ProgressTask(20, 10);
completedCounter = 0;
// add the simple task 100 times.
for (var i = 0; i < taskCount; i++)
{
managedTasks.Add("123", "task3", "test", 0, "id", i, managedObject, null, null);
}
// use cancellation token to ensure test doesn't get stuck forever.
var cts = new CancellationTokenSource();
cts.CancelAfter(30000);
await managedTasks.WhenAll(cts.Token);
Assert.Equal(taskCount, managedTasks.GetCompletedTasks().Count());
Assert.Equal(taskCount, managedTasks.CompletedCount);
// counter should equal the number of tasks8
_output.WriteLine($"runningCounter: {runningCounter}, completedCounter: {completedCounter}");
Assert.Equal(taskCount, runningCounter);
Assert.Equal(taskCount, completedCounter);
Assert.Empty(managedTasks);
Assert.Empty(managedTasks.GetActiveTasks());
Assert.Empty(managedTasks.GetRunningTasks());
// check the changes history
var changes = managedTasks.GetTaskChanges().ToArray();
Assert.Equal(taskCount, changes.Count());
foreach (var change in changes)
{
Assert.Equal(EManagedTaskStatus.Completed, change.Status);
}
}
