public async Task Test_1ManagedTaskAsync() { var managedTasks = new ManagedTasks.ManagedTasks(); _progressCounter = 0; managedTasks.OnProgress += Progress; var progressTask = new ProgressTask(20, 5); var task1 = managedTasks.Add("123", "task", "test", progressTask, null); //check properties are set correctly. Assert.Equal("123", task1.OriginatorId); Assert.Equal("task", task1.Name); Assert.Equal("test", task1.Category); var cts = new CancellationTokenSource(); cts.CancelAfter(30000); await managedTasks.WhenAll(cts.Token); Assert.Single(managedTasks.GetCompletedTasks()); // ensure the progress was called at least once. // This doesn't get called for every progress event as when they stack up they get dropped // which is expected bahaviour. Assert.True(_progressCounter > 0); }
public async Task Test_ManagedTask_CancelAsync() { var managedTasks = new ManagedTasks.ManagedTasks(); // simple task that can be cancelled var managedObject = new ProgressTask(10000, 1); // add the simple task 500 times. _cancelCounter = 0; managedTasks.OnStatus += CancelResult; var tasks = new ManagedTask[100]; for (var i = 0; i < 100; i++) { tasks[i] = managedTasks.Add("123", "task3", "test", managedObject, null); } for (var i = 0; i < 100; i++) { await tasks[i].CancelAsync(); } var cts = new CancellationTokenSource(); cts.CancelAfter(30000); await managedTasks.WhenAll(cts.Token); // counter should equal the number of tasks Assert.Equal(100, _cancelCounter); Assert.Empty(managedTasks); }
public async Task Test_ManagedTask_ProgressError() { using (var managedTasks = new ManagedTasks.ManagedTasks()) { var errorCount = 0; var managedTask = new ProgressTask(1, 5); void Progress(ManagedTask task, ManagedTaskProgressItem progress) { throw new Exception("Failed"); } // add the error task multiple times. errorCount = 0; managedTasks.OnProgress += Progress; var t = managedTasks.Add("123", "task3", "test", managedTask, null); await managedTasks.WhenAll(); // Assert.True(t.Exception != null); t = managedTasks.Add("123", "task3", "test", managedTask, null); await managedTasks.WhenAll(); Assert.True(t.Exception != null); PrintManagedTasksCounters(managedTasks); } }
public async Task ParallelManagedTaskHandlerConcurrentAsync(int taskCount) { var managedTasks = new ManagedTasks.ManagedTasks(); var oneSecondTask = new ProgressTask(1, 1); for (var i = 0; i < taskCount; i++) { var task = new ManagedTask() { TaskId = Guid.NewGuid().ToString(), CategoryKey = i, Name = "task", Category = "123", ManagedObject = oneSecondTask }; managedTasks.Add(task); } var cts = new CancellationTokenSource(); cts.CancelAfter(30000); await managedTasks.WhenAll(cts.Token); PrintManagedTasksCounters(managedTasks); Assert.Equal(taskCount, managedTasks.CompletedCount); }
public async Task Test_ManagedTask_ScheduleAsync() { var managedTasks = new ManagedTasks.ManagedTasks(); // simple task that takes 5 seconds var managedObject = new ProgressTask(5000, 1); var currentDate = DateTime.Now; // set a trigger 5 seconds in the future var trigger = new ManagedTaskTrigger() { StartDate = currentDate, StartTime = currentDate.AddSeconds(5).TimeOfDay, IntervalType = EIntervalType.Once }; _output.WriteLine($"Time to Start: {trigger.NextOccurrence(DateTime.Now)-DateTime.Now}"); var task1 = managedTasks.Add("123", "task3", "test", managedObject, new[] { trigger }); var cts = new CancellationTokenSource(); cts.CancelAfter(30000); await managedTasks.WhenAll(cts.Token); // time should be startDate + 5 second for the job to run. Assert.True(trigger.StartDate.Value.AddSeconds(5) < DateTime.Now); }
private void PrintManagedTasksCounters(ManagedTasks.ManagedTasks managedTasks) { _output.WriteLine($"Create tasks count: {managedTasks.CreatedCount }"); _output.WriteLine($"Queued tasks count: {managedTasks.QueuedCount }"); _output.WriteLine($"Running tasks count: {managedTasks.RunningCount }"); _output.WriteLine($"Scheduled tasks count: {managedTasks.ScheduledCount }"); _output.WriteLine($"Completed tasks count: {managedTasks.CompletedCount }"); _output.WriteLine($"Cancel tasks count: {managedTasks.CancelCount }"); _output.WriteLine($"Error tasks count: {managedTasks.ErrorCount }"); }
public async Task Test_Add_SameTask_ActionsAsync(EConcurrentTaskAction concurrentTaskAction) { var managedTasks = new ManagedTasks.ManagedTasks(); var task1 = new ManagedTask { TaskId = Guid.NewGuid().ToString(), OriginatorId = "task", Name = "test", Category = "category", CategoryKey = 1, ReferenceKey = 1, ReferenceId = "id", ManagedObject = new ProgressTask(20, 1), Triggers = null, FileWatchers = null, DependentTaskIds = null, ConcurrentTaskAction = EConcurrentTaskAction.Sequence }; var task2 = new ManagedTask { TaskId = Guid.NewGuid().ToString(), OriginatorId = "task", Name = "test", Category = "category", CategoryKey = 1, ReferenceKey = 2, ReferenceId = "id", ManagedObject = new ProgressTask(0, 1), Triggers = null, FileWatchers = null, DependentTaskIds = null, ConcurrentTaskAction = concurrentTaskAction }; managedTasks.Add(task1); managedTasks.Add(task2); await managedTasks.WhenAll(); if (concurrentTaskAction == EConcurrentTaskAction.Parallel) { Assert.True(task1.EndTime > task2.EndTime); } else { Assert.True(task1.EndTime < task2.EndTime); } Assert.Equal(2, managedTasks.ErrorCount + managedTasks.CompletedCount); }
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_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); }
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); }
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); }
public async Task Test_ManagedTask_ErrorAsync(int taskCount) { using (var managedTasks = new ManagedTasks.ManagedTasks()) { var errorCount = 0; var managedTask = new ErrorTask(); void ErrorResult(ManagedTask task, EManagedTaskStatus status) { if (status == EManagedTaskStatus.Error) { Assert.True(task.Exception != null); Interlocked.Increment(ref errorCount); } } // add the error task multiple times. errorCount = 0; managedTasks.OnStatus += ErrorResult; for (var i = 0; i < taskCount; i++) { managedTasks.Add("123", "task3", "test", managedTask, null); } var cts = new CancellationTokenSource(); cts.CancelAfter(30000); await managedTasks.WhenAll(cts.Token); PrintManagedTasksCounters(managedTasks); _output.WriteLine($"Error count {errorCount}, error count in tasks {managedTasks.ErrorCount}"); // all error counters should equal the number of tasks Assert.Equal(taskCount, managedTasks.ErrorCount); Assert.Equal(taskCount, errorCount); Assert.Empty(managedTasks); } }
// 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); } }
public async Task Test_ManagedTask_FileWatcherAsync() { var path = Path.Combine(Directory.GetCurrentDirectory(), "TestFiles"); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } var managedTasks = new ManagedTasks.ManagedTasks(); var startTime = DateTime.Now; _output.WriteLine($"Started at {DateTime.Now}."); var fileDelete = new FileDeleteTask(path); var fileWatchCount = 0; void OnFileWatch(object sender, EManagedTaskStatus status) { if (status == EManagedTaskStatus.FileWatching) { Interlocked.Increment(ref fileWatchCount); } } managedTasks.OnStatus += OnFileWatch; _output.WriteLine($"Step 1 {DateTime.Now}."); var fileWatch = new ManagedTaskFileWatcher(path, "*"); _output.WriteLine($"Step 1a {DateTime.Now}."); var fileTask = managedTasks.Add("123", "task3", "test", fileDelete, null, new[] { fileWatch }); var startTime2 = DateTime.Now; _output.WriteLine($"Step 2 {startTime2}."); for (var i = 0; i < 5; i++) { File.Create(Path.Combine(path, "test-" + Guid.NewGuid())).Close(); await Task.Delay(1000); } await fileTask.CancelAsync(); var cts = new CancellationTokenSource(); cts.CancelAfter(10000); await managedTasks.WhenAll(cts.Token); // file watch count will be 6. One for each file (5), and then another for the next watcher that was started before the cancel. Assert.Equal(6, fileWatchCount); Assert.Equal(6, managedTasks.FileWatchCount); Assert.Equal(5, managedTasks.CompletedCount); // should 5 seconds (with tolerance) _output.WriteLine($"Finished {DateTime.Now}."); Assert.True(startTime2.AddSeconds(5) < DateTime.Now && startTime2.AddSeconds(5.5) > DateTime.Now); }