public void ReportProgress()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create();
this.Repository.TaskRuntimeInfo.Add(taskInfo);
FakeTask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
double percent = DateTime.Now.Second;
using (FakeTaskWorker worker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task));
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
worker.RaiseReportProgress(percent);
}
this.MessageBus.Tasks.Receiver.AssertMethodCallOnceWithArguments(mb => mb.NotifyTaskProgress(taskInfo.TaskId, percent));
this.Repository.TaskRuntimeInfo.AssertMethodCallOnceWithArguments(r => r.Progress(taskInfo.TaskId, percent));
}
public void CancelTaskMultipleTimes()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add();
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
using (FakeTaskWorker taskWorker = new FakeTaskWorker())
{
taskWorker.PredefineMethodCall(w => w.StartTask(task, null), () => Thread.Sleep(TimeSpan.FromSeconds(1)));
this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task));
for (int i = 0; i < 3; i++)
{
ThreadPool.QueueUserWorkItem(_ =>
{
Thread.Sleep(TimeSpan.FromSeconds(0.3));
this.MessageBus.Tasks.NotifyTaskCancelRequest(taskInfo.TaskId, DateTime.UtcNow);
});
}
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
Thread.Sleep(TimeSpan.FromSeconds(0.5));
taskWorker.AssertMethodCallOnceWithArguments(w => w.CancelTask());
}
this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels());
}
public void CancelTask()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create();
this.Repository.TaskRuntimeInfo.Add(taskInfo);
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
using (FakeTaskWorker taskWorker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task));
taskWorker.PredefineMethodCall(w => w.StartTask(task, null), () => Thread.Sleep(TimeSpan.FromSeconds(1)));
ThreadPool.QueueUserWorkItem(_ => this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId));
Thread.Sleep(TimeSpan.FromSeconds(0.5));
this.DateTimeProvider.UtcNow = DateTime.UtcNow;
this.MessageBus.Tasks.NotifyTaskCancelRequest(taskInfo.TaskId, this.DateTimeProvider.UtcNow);
Thread.Sleep(TimeSpan.FromSeconds(1.5));
taskWorker.AssertMethodCallOnce(w => w.CancelTask());
taskWorker.AssertMethodCallOnce(w => w.Dispose());
}
this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels());
}
public void Fail()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add();
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
this.DateTimeProvider.UtcNow = DateTime.UtcNow;
Exception error = new TypeNotFoundInRedisException("Dummy Error");
using (FakeTaskWorker worker = new FakeTaskWorker())
{
worker.PredefineMethodCall(w => w.StartTask(task, null), () => { throw error; });
this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task));
try
{
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
}
catch (TypeNotFoundInRedisException)
{
}
worker.AssertMethodCallOnce(w => w.Dispose());
}
this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels());
this.Repository.TaskRuntimeInfo.AssertMethodCallOnceWithArguments(r => r.Fail(taskInfo.TaskId, this.DateTimeProvider.UtcNow, error));
}
public void StartTaskWithTaskJobSettings()
{
this.Configuration.Get <FakeTask>().HasTaskJobSettings = true;
ITaskJobSettings settings = new FakeTaskJobSettings();
this.Repository.TaskJobSettings.Set <FakeTask>(settings);
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create();
FakeTask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
this.Repository.TaskRuntimeInfo.Add(taskInfo);
using (FakeTaskWorker taskWorker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task));
this.DateTimeProvider.UtcNow = DateTime.UtcNow;
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
this.TaskWorkerFactory.AssertMethodCallOnceWithArguments(f => f.CreateTaskWorker(task));
taskWorker.AssertMethodCallOnce(w => w.StartTask(task, settings));
}
}
public void StartTaskRuntimeInfoNotFound()
{
Guid taskId = Guid.NewGuid();
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskId, task);
using (FakeTaskWorker worker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task));
}
this.TaskWorkerBootstrap.StartTask(taskId);
}
public void AddTask()
{
Guid taskId = Guid.NewGuid();
FakeTask task1 = new FakeTask()
{
StringValue = "Hello World",
NumberValue = DateTime.UtcNow.Millisecond
};
this.Repository.Add(taskId, task1);
FakeTask task2 = (FakeTask)this.Repository.GetById(taskId);
UnitTestHelpers.AssertEqualByPublicScalarProperties(task1, task2);
}
public void StartTaskCanceled()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add();
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
using (FakeTaskWorker worker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task));
this.Repository.TaskRuntimeInfo.RequestCancel(taskInfo.TaskId, DateTime.UtcNow);
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
}
}
public void Delete()
{
Guid taskId = Guid.NewGuid();
FakeTask task = new FakeTask()
{
StringValue = "Hello World",
NumberValue = DateTime.UtcNow.Millisecond
};
this.Repository.Add(taskId, task);
Assert.IsNotNull(this.Repository.GetById(taskId));
this.Repository.Delete(taskId);
Assert.IsNull(this.Repository.GetById(taskId));
}
private void StartTaskCompleted(Action <Guid> completeTask)
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create();
this.Repository.TaskRuntimeInfo.Add(taskInfo);
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
using (FakeTaskWorker worker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task));
}
completeTask(taskInfo.TaskId);
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
}
public void CancelAnotherTask()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create();
this.Repository.TaskRuntimeInfo.Add(taskInfo);
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
using (FakeTaskWorker taskWorker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task));
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
this.MessageBus.Tasks.NotifyTaskCancelRequest(Guid.NewGuid(), DateTime.UtcNow);
Thread.Sleep(TimeSpan.FromSeconds(0.5));
taskWorker.AssertNoMethodCall(w => w.CancelTask());
}
}
public void Complete()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add();
ITask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
this.DateTimeProvider.UtcNow = DateTime.UtcNow;
using (FakeTaskWorker taskWorker = new FakeTaskWorker())
{
taskWorker.PredefineMethodCall(w => w.StartTask(task, null), () => { });
this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task));
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
taskWorker.AssertMethodCallOnce(w => w.Dispose());
}
this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels());
}
public void StartTaskNoTaskJobSettings()
{
ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create();
FakeTask task = new FakeTask();
this.Repository.Tasks.Add(taskInfo.TaskId, task);
this.Repository.TaskRuntimeInfo.Add(taskInfo);
this.DateTimeProvider.UtcNow = DateTime.UtcNow;
using (FakeTaskWorker taskWorker = new FakeTaskWorker())
{
this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task));
this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId);
this.TaskWorkerFactory.AssertMethodCallOnceWithArguments(f => f.CreateTaskWorker(task));
taskWorker.AssertMethodCallOnce(w => w.StartTask(task, null));
}
}
private void SubmitTask(bool isPollingQueueTask, bool hasSummary, TaskPriority expectedPriority, Func <ITask, ITaskSummary, Guid> submitCallback)
{
this.DateTimeProvider.UtcNow = DateTime.UtcNow.AddMinutes(-1);
FakeTask task1 = new FakeTask()
{
StringValue = "Hello Submit Task",
NumberValue = 1234567
};
StringTaskSummary summary1;
if (hasSummary)
{
summary1 = new StringTaskSummary("Hello World");
}
this.Configuration.PredefineResult(isPollingQueueTask ? "Test" : null, c => c.GetPollingQueueKey(task1.GetType()));
Guid taskId = submitCallback(task1, summary1);
Assert.IsNotNull(this.TaskProcessorFacade.GetTask(taskId));
ITaskRuntimeInfo taskInfo = this.TaskProcessorFacade.GetTaskRuntimeInfo(taskId);
Assert.IsNotNull(taskInfo);
Assert.AreEqual(taskId, taskInfo.TaskId);
Assert.AreEqual(expectedPriority, taskInfo.Priority);
Assert.AreEqual(TaskStatus.Pending, taskInfo.Status);
Assert.AreEqual(this.DateTimeProvider.UtcNow, taskInfo.SubmittedUtc);
FakeTask task2 = (FakeTask)this.Repository.Tasks.GetById(taskId);
UnitTestHelpers.AssertEqualByPublicScalarProperties(task1, task2);
if (hasSummary)
{
StringTaskSummary summary2 = (StringTaskSummary)this.Repository.TaskSummary.GetById(taskId);
Assert.AreEqual(summary1.Summary, summary2.Summary);
}
TaskSubmittedMasterCommand message = this.TaskProcessorFacade.MessageBus.MasterCommands
.OfType <TaskSubmittedMasterCommand>()
.SingleOrDefault(m => m.TaskId == taskId);
if (isPollingQueueTask)
{
Assert.IsNull(message);
Assert.IsTrue(this.Repository.TaskRuntimeInfo.GetPending(true).Any(p => p.TaskId == taskId));
Assert.IsTrue(this.Repository.TaskRuntimeInfo.ReservePollingQueueTasks("Test", int.MaxValue).Any(p => p.TaskId == taskId));
}
else
{
Assert.IsNotNull(message);
Assert.AreNotEqual(Guid.Empty, message.MessageUniqueId);
Assert.AreEqual(taskId, message.TaskId);
Assert.IsTrue(this.Repository.TaskRuntimeInfo.GetPending(false).Any(p => p.TaskId == taskId));
}
}
