public void AddPollingQueueCopy()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingQueues.AddCopy(new FakePollingQueueConfiguration()
{
Key = "A",
PollInterval = TimeSpan.FromSeconds(1),
IsActive = true
});
processorInfo.Configuration.PollingQueues.AddCopy(new FakePollingQueueConfiguration()
{
Key = "B",
PollInterval = TimeSpan.FromSeconds(2),
IsMaster = true,
MaxWorkers = 0
});
processorInfo.Configuration.PollingQueues.AddCopy(new FakePollingQueueConfiguration()
{
Key = "C",
PollInterval = TimeSpan.FromSeconds(3),
IsConcurrent = true,
MaxWorkers = 12
});
this.Repository.Update(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
Assert.AreEqual("A", processorInfo.Configuration.PollingQueues["A"].Key);
Assert.AreEqual(TimeSpan.FromSeconds(1), processorInfo.Configuration.PollingQueues["A"].PollInterval);
Assert.IsTrue(processorInfo.Configuration.PollingQueues["A"].IsActive);
Assert.IsFalse(processorInfo.Configuration.PollingQueues["A"].IsMaster);
Assert.IsFalse(processorInfo.Configuration.PollingQueues["A"].IsConcurrent);
Assert.AreEqual(0, processorInfo.Configuration.PollingQueues["A"].MaxWorkers);
Assert.AreEqual("B", processorInfo.Configuration.PollingQueues["B"].Key);
Assert.AreEqual(TimeSpan.FromSeconds(2), processorInfo.Configuration.PollingQueues["B"].PollInterval);
Assert.IsFalse(processorInfo.Configuration.PollingQueues["B"].IsActive);
Assert.IsTrue(processorInfo.Configuration.PollingQueues["B"].IsMaster);
Assert.IsFalse(processorInfo.Configuration.PollingQueues["B"].IsConcurrent);
Assert.AreEqual(0, processorInfo.Configuration.PollingQueues["B"].MaxWorkers);
Assert.AreEqual("C", processorInfo.Configuration.PollingQueues["C"].Key);
Assert.AreEqual(TimeSpan.FromSeconds(3), processorInfo.Configuration.PollingQueues["C"].PollInterval);
Assert.IsFalse(processorInfo.Configuration.PollingQueues["C"].IsActive);
Assert.IsFalse(processorInfo.Configuration.PollingQueues["C"].IsMaster);
Assert.IsTrue(processorInfo.Configuration.PollingQueues["C"].IsConcurrent);
Assert.AreEqual(12, processorInfo.Configuration.PollingQueues["C"].MaxWorkers);
}
public void RemoveTaskJobSystemConfiguration()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.Tasks.Add(typeof(IFakeTask));
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
Assert.IsNotNull(processorInfo.Configuration.Tasks[typeof(IFakeTask)]);
processorInfo.Configuration.Tasks.Remove(typeof(IFakeTask));
Assert.IsNull(processorInfo.Configuration.Tasks[typeof(IFakeTask)]);
this.Repository.Update(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
Assert.IsNull(processorInfo.Configuration.Tasks[typeof(IFakeTask)]);
}
public void AddPollingJobCopy()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingJobs.AddCopy(new FakePollingJobConfiguration()
{
ImplementationType = typeof(FakePollingJob),
PollInterval = TimeSpan.FromMinutes(1),
IsMaster = true,
IsActive = true
});
IPollingJobConfiguration result = processorInfo.Configuration.PollingJobs[typeof(FakePollingJob)];
Assert.AreEqual(typeof(FakePollingJob), result.ImplementationType);
Assert.AreEqual(TimeSpan.FromMinutes(1), result.PollInterval);
Assert.IsTrue(result.IsMaster);
Assert.IsTrue(result.IsActive);
}
private void ChooseNextTaskForProcessorOrder(TaskPriority higher, TaskPriority smaller)
{
FakeTaskProcessorRuntimeInfo taskProcessorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.TaskProcessorRuntimeInfo.Add(taskProcessorInfo);
FakeTaskRuntimeInfo pendingTaskInfo1 = this.Repository.TaskRuntimeInfo.Create <FakeTaskRuntimeInfo>();
pendingTaskInfo1.Priority = smaller;
this.Repository.TaskRuntimeInfo.Add(pendingTaskInfo1);
FakeTaskRuntimeInfo pendingTaskInfo2 = this.Repository.TaskRuntimeInfo.Create <FakeTaskRuntimeInfo>();
pendingTaskInfo1.Priority = higher;
this.Repository.TaskRuntimeInfo.Add(pendingTaskInfo2);
var result = this.TaskDistributor.ChooseNextTasksForProcessor(taskProcessorInfo.TaskProcessorId);
Assert.AreEqual(2, result.Count());
Assert.AreEqual(pendingTaskInfo2, result.First());
Assert.AreEqual(pendingTaskInfo1, result.Last());
}
public void ChooseNextTaskForProcessorSkipProcessorTaskJob()
{
FakeTaskProcessorRuntimeInfo taskProcessorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
taskProcessorInfo.Configuration.Tasks.Add(typeof(FakeTask)).MaxWorkers = 1;
this.Repository.TaskProcessorRuntimeInfo.Add(taskProcessorInfo);
FakeTaskRuntimeInfo pendingTaskToSkip = this.Repository.TaskRuntimeInfo.Create <FakeTaskRuntimeInfo>();
pendingTaskToSkip.Priority = TaskPriority.Low;
this.Repository.TaskRuntimeInfo.Add(pendingTaskToSkip);
FakeTaskRuntimeInfo pendingTask = this.Repository.TaskRuntimeInfo.Create <FakeTaskRuntimeInfo>();
pendingTask.Priority = TaskPriority.High;
this.Repository.TaskRuntimeInfo.Add(pendingTask);
IEnumerable <ITaskRuntimeInfo> result = this.TaskDistributor.ChooseNextTasksForProcessor(taskProcessorInfo.TaskProcessorId);
Assert.AreEqual(pendingTask, result.Single());
}
public void ChooseProcessorForTask()
{
ITaskProcessorRuntimeInfo processorInfo1 = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid()
};
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo1);
ITaskProcessorRuntimeInfo processorInfo2 = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid()
};
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo2);
ITaskRuntimeInfo activeTaskInfo = this.Repository.TaskRuntimeInfo.Create();
this.Repository.TaskRuntimeInfo.Add(activeTaskInfo);
this.Repository.TaskRuntimeInfo.Start(activeTaskInfo.TaskId, processorInfo1.TaskProcessorId, DateTime.UtcNow);
var result = this.TaskDistributor.ChooseProcessorForTask(new FakeTaskRuntimeInfo());
Assert.AreEqual(processorInfo2, result.First());
Assert.AreEqual(processorInfo1, result.Last());
}
public void PollingJobsConfiguration()
{
FakeTaskProcessorRuntimeInfo processorInfo1 = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo1.Configuration.PollingJobs.Add(new FakePollingJobConfiguration()
{
ImplementationType = typeof(FakePollingJob),
PollInterval = TimeSpan.FromMinutes(1),
IsMaster = true
});
processorInfo1.Configuration.PollingJobs.Add(new FakePollingJobConfiguration()
{
ImplementationType = typeof(FakePollingJob2),
PollInterval = TimeSpan.FromMinutes(2),
IsActive = true
});
processorInfo1.Configuration.PollingJobs.Add(new FakePollingJobConfiguration()
{
ImplementationType = typeof(FakePollingJob3),
PollInterval = TimeSpan.FromMinutes(3),
IsConcurrent = true
});
this.Repository.Add(processorInfo1);
ITaskProcessorRuntimeInfo processorInfo2 = this.Repository.GetById(processorInfo1.TaskProcessorId);
Assert.AreEqual(3, processorInfo2.Configuration.PollingJobs.Count());
IPollingJobConfiguration queue1 = processorInfo2.Configuration.PollingJobs.First(q => q.ImplementationType == typeof(FakePollingJob));
Assert.AreEqual(TimeSpan.FromMinutes(1), queue1.PollInterval);
Assert.IsTrue(queue1.IsMaster);
Assert.IsFalse(queue1.IsActive);
Assert.IsFalse(queue1.IsConcurrent);
IPollingJobConfiguration queue2 = processorInfo2.Configuration.PollingJobs.First(q => q.ImplementationType == typeof(FakePollingJob2));
Assert.AreEqual(TimeSpan.FromMinutes(2), queue2.PollInterval);
Assert.IsFalse(queue2.IsMaster);
Assert.IsTrue(queue2.IsActive);
Assert.IsFalse(queue2.IsConcurrent);
IPollingJobConfiguration queue3 = processorInfo2.Configuration.PollingJobs.First(q => q.ImplementationType == typeof(FakePollingJob3));
Assert.AreEqual(TimeSpan.FromMinutes(3), queue3.PollInterval);
Assert.IsFalse(queue3.IsMaster);
Assert.IsFalse(queue3.IsActive);
Assert.IsTrue(queue3.IsConcurrent);
}
public void PollingQueuesConfiguration()
{
FakeTaskProcessorRuntimeInfo processorInfo1 = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo1.Configuration.PollingQueues.Add(new FakePollingQueueConfiguration()
{
Key = "A",
PollInterval = TimeSpan.FromMinutes(1),
IsMaster = true
});
processorInfo1.Configuration.PollingQueues.Add(new FakePollingQueueConfiguration()
{
Key = "B",
PollInterval = TimeSpan.FromMinutes(2),
IsActive = true
});
processorInfo1.Configuration.PollingQueues.Add(new FakePollingQueueConfiguration()
{
Key = "C",
PollInterval = TimeSpan.FromMinutes(3),
IsConcurrent = true
});
this.Repository.Add(processorInfo1);
ITaskProcessorRuntimeInfo processorInfo2 = this.Repository.GetById(processorInfo1.TaskProcessorId);
Assert.AreEqual(3, processorInfo2.Configuration.PollingQueues.Count());
ITaskProcessorPollingQueueConfiguration queue = processorInfo2.Configuration.PollingQueues.First(q => q.Key == "A");
Assert.AreEqual(TimeSpan.FromMinutes(1), queue.PollInterval);
Assert.IsTrue(queue.IsMaster);
Assert.IsFalse(queue.IsActive);
Assert.IsFalse(queue.IsConcurrent);
queue = processorInfo2.Configuration.PollingQueues.First(q => q.Key == "B");
Assert.AreEqual(TimeSpan.FromMinutes(2), queue.PollInterval);
Assert.IsFalse(queue.IsMaster);
Assert.IsTrue(queue.IsActive);
Assert.IsFalse(queue.IsConcurrent);
queue = processorInfo2.Configuration.PollingQueues.First(q => q.Key == "C");
Assert.AreEqual(TimeSpan.FromMinutes(3), queue.PollInterval);
Assert.IsFalse(queue.IsMaster);
Assert.IsFalse(queue.IsActive);
Assert.IsTrue(queue.IsConcurrent);
}
public void ChooseProcessorForTaskExceedProcessorMaxWorkers()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.Tasks.MaxWorkers = 0;
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo);
Assert.IsFalse(this.TaskDistributor.ChooseProcessorForTask(new FakeTaskRuntimeInfo()).Any());
}
public void AddPollingQueueCopyNull()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingQueues.AddCopy(null);
}
public void AddNullTaskJobCopy()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.Tasks.AddCopy(default(ITaskJobConfiguration));
}
public void NegativeTaskJobsMaxWorkers()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.Tasks.MaxWorkers = -1;
}
public void RemovePollingJobConfigurationNullImplementationType()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingJobs.Remove(null);
}
public void RemovePollingJobConfigurationNotDescendant2()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingJobs.Remove(typeof(ICloneable));
}
public void RemoveTaskJobNull()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.Tasks.Remove(null);
}
public void AddPollingJobImplementationTypeNotDescendant1()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingJobs.Add(typeof(IPollingJob));
}
public void Add(ITaskProcessorRuntimeInfo taskProcessorInfo)
{
if (taskProcessorInfo == null)
{
throw new ArgumentNullException("taskProcessorInfo");
}
this.RecordMethodCall(taskProcessorInfo);
FakeTaskProcessorRuntimeInfo fakeProcessor = (FakeTaskProcessorRuntimeInfo)taskProcessorInfo;
fakeProcessor.ExpireAt = DateTime.Now + this.Expiration;
this.taskProcessors.Add(taskProcessorInfo.TaskProcessorId, fakeProcessor);
}
public void AddPollingJobDuplicate()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingJobs.Add(typeof(FakePollingJob));
processorInfo.Configuration.PollingJobs.Add(typeof(FakePollingJob));
}
public void ChooseProcessorForTaskEmptyConfiguration()
{
FakeTaskProcessorRuntimeInfo taskProcessorInfo = new FakeTaskProcessorRuntimeInfo()
{
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.TaskProcessorRuntimeInfo.Add(taskProcessorInfo);
var result = this.TaskDistributor.ChooseProcessorForTask(new FakeTaskRuntimeInfo()
{
TaskType = typeof(FakeTask)
});
Assert.AreEqual(taskProcessorInfo, result.Single());
}
public void GetPollingJobImplementationTypeNotDescendant2()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
if (processorInfo.Configuration.PollingJobs[typeof(ICloneable)] != null)
{
}
}
public void ChooseProcessorForTask()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.Tasks.MaxWorkers = 1;
processorInfo.Configuration.Tasks.Add(typeof(FakeTask)).MaxWorkers = 1;
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo);
Assert.AreEqual(processorInfo, this.TaskDistributor.ChooseProcessorForTask(new FakeTaskRuntimeInfo()
{
TaskType = typeof(FakeTask)
}).Single());
}
public void ChooseProcessorForTaskExceedProcessorTaskJobMaxWorkers()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.Tasks.Add(typeof(FakeTask)).MaxWorkers = 0;
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo);
Assert.IsFalse(this.TaskDistributor.ChooseProcessorForTask(new FakeTaskRuntimeInfo()
{
TaskType = typeof(FakeTask)
}).Any());
}
public void GetTaskJobNull()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.Tasks.Add(typeof(IFakeTask));
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
if (processorInfo.Configuration.Tasks[null] == null)
{
}
}
public void AddDuplicateTaskJob2()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.Tasks.Add(typeof(FakeTask));
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.Tasks.AddCopy(new FakeTaskJobConfiguration()
{
TaskType = typeof(FakeTask)
});
}
public void RemovePollingJobConfiguration()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo.Configuration.PollingJobs.Add(typeof(FakePollingJob)).PollInterval = TimeSpan.FromMinutes(1);
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
Assert.IsNotNull(processorInfo.Configuration.PollingJobs[typeof(FakePollingJob)]);
processorInfo.Configuration.PollingJobs.Remove(typeof(FakePollingJob));
Assert.IsNull(processorInfo.Configuration.PollingJobs[typeof(FakePollingJob)]);
}
public void ZeroTaskJobsMaxWorkers()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.Tasks.MaxWorkers = 0;
this.Repository.Update(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
Assert.AreEqual(0, processorInfo.Configuration.Tasks.MaxWorkers);
}
public void AddPollingQueueCopyDuplicate()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingQueues.Add("A");
processorInfo.Configuration.PollingQueues.AddCopy(new FakePollingQueueConfiguration()
{
Key = "A",
PollInterval = TimeSpan.FromSeconds(1)
});
}
public void AddPollingJobCopyDuplicate()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
processorInfo.Configuration.PollingJobs.Add(typeof(FakePollingJob));
processorInfo.Configuration.PollingJobs.AddCopy(new FakePollingJobConfiguration()
{
ImplementationType = typeof(FakePollingJob),
PollInterval = TimeSpan.FromMinutes(1)
});
}
public void AddPollingJob()
{
ITaskProcessorRuntimeInfo processorInfo = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
this.Repository.Add(processorInfo);
processorInfo = this.Repository.GetById(processorInfo.TaskProcessorId);
IPollingJobConfiguration result = processorInfo.Configuration.PollingJobs.Add(typeof(FakePollingJob));
Assert.AreEqual(typeof(FakePollingJob), result.ImplementationType);
result = processorInfo.Configuration.PollingJobs[typeof(FakePollingJob)];
Assert.AreEqual(typeof(FakePollingJob), result.ImplementationType);
}
public void ChooseNextTaskForProcessor()
{
ITaskProcessorRuntimeInfo processorInfo1 = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo1.Configuration.Tasks.MaxWorkers = 4;
processorInfo1.Configuration.Tasks.Add(typeof(IFakeTask)).MaxWorkers = 2;
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo1);
ITaskProcessorRuntimeInfo processorInfo2 = new FakeTaskProcessorRuntimeInfo()
{
TaskProcessorId = Guid.NewGuid(),
Configuration = new FakeTaskProcessorConfiguration()
};
processorInfo2.Configuration.Tasks.MaxWorkers = 1;
this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo2);
ITaskRuntimeInfo pendingTaskInfo1 = this.Repository.TaskRuntimeInfo.Add(TaskPriority.High);
ITaskRuntimeInfo pendingTaskInfo2 = this.Repository.TaskRuntimeInfo.Add(TaskPriority.VeryHigh);
ITaskRuntimeInfo activeTaskInfo1 = this.Repository.TaskRuntimeInfo.Add();
ITaskRuntimeInfo activeTaskInfo2 = this.Repository.TaskRuntimeInfo.Add();
ITaskRuntimeInfo activeTaskInfo3 = this.Repository.TaskRuntimeInfo.Add();
this.Repository.TaskRuntimeInfo.Start(activeTaskInfo1.TaskId, Guid.NewGuid(), DateTime.UtcNow);
this.Repository.TaskRuntimeInfo.Start(activeTaskInfo2.TaskId, processorInfo1.TaskProcessorId, DateTime.UtcNow);
this.Repository.TaskRuntimeInfo.Start(activeTaskInfo3.TaskId, processorInfo1.TaskProcessorId, DateTime.UtcNow);
IEnumerable <ITaskRuntimeInfo> result = this.TaskDistributor.ChooseNextTasksForProcessor(processorInfo1.TaskProcessorId);
Assert.AreEqual(2, result.Count());
Assert.AreEqual(pendingTaskInfo2, result.First());
Assert.AreEqual(pendingTaskInfo1, result.Last());
}
