public void ItExecutesTasksAtTheSpecifiedInterval()
{
var semaphoreFile = Path.GetTempFileName();
File.Delete(semaphoreFile);
var intervalSeconds = 2;
var taskScheduler = new TaskScheduler(TaskQueue.Redis("localhost:6379"));
taskScheduler.AddScheduledTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
TimeSpan.FromSeconds(intervalSeconds), "test");
taskScheduler.Tick();
File.Exists(semaphoreFile).Should().Be(false);
// Confirm Scheduled Task Ran once
Thread.Sleep(((intervalSeconds) * 1000) + 10);
taskScheduler.Tick();
File.Exists(semaphoreFile).Should().Be(true);
File.ReadAllText(semaphoreFile).Should().Be(TaskQueueTestFixture.SemaphoreText);
// Confirm Ran TWICE
Thread.Sleep(((intervalSeconds) * 1000) + 10);
taskScheduler.Tick();
File.Exists(semaphoreFile).Should().Be(true);
File.ReadAllText(semaphoreFile).Should()
.Be(TaskQueueTestFixture.SemaphoreText + TaskQueueTestFixture.SemaphoreText);
}
public void ItExecutesAScheduledTaskAtTheSpecifiedDateTimeOnlyOnce()
{
Action <string, TaskScheduler> configureSchedulerAction = (semaphoreFile, taskScheduler) =>
{
taskScheduler.AddScheduledTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
DateTime.UtcNow + TimeSpan.FromSeconds(IntervalSeconds), RandomTaskName);
};
AssertTaskSchedulerWritesSemaphoreOnlyOnce(configureSchedulerAction);
}
public void ItExecutesARecurringTaskAtTheSpecifiedCrontabInterval()
{
Action <string, TaskScheduler> configureSchedulerAction = (semaphoreFile, taskScheduler) =>
{
taskScheduler.AddRecurringTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
$"*/{IntervalSeconds} * * * * *", RandomTaskName);
};
AssertTaskSchedulerWritesSemaphoreTwice(configureSchedulerAction);
}
public void ItExecutesTasksOnlyOnceWhenUsingMultipleConsumers()
{
var semaphoreFile = Path.GetTempFileName();
File.Delete(semaphoreFile);
File.Create(semaphoreFile).Close();
var intervalSeconds = 5;
var taskSchedulers = new[]
{
new TaskScheduler(TaskQueue.Redis("localhost:6379")),
new TaskScheduler(TaskQueue.Redis("localhost:6379")),
new TaskScheduler(TaskQueue.Redis("localhost:6379")),
new TaskScheduler(TaskQueue.Redis("localhost:6379"))
};
foreach (var taskScheduler in taskSchedulers)
{
taskScheduler.AddScheduledTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
TimeSpan.FromSeconds(intervalSeconds), "test");
}
Thread.Sleep(((intervalSeconds) * 1000) + 1000);
// Ran only once
Task.WaitAll(
taskSchedulers.Select(
taskScheduler =>
Task.Run(() => taskScheduler.Tick())).ToArray(), 1000);
File.Exists(semaphoreFile).Should().Be(true);
File.ReadAllText(semaphoreFile).Should().Be(TaskQueueTestFixture.SemaphoreText);
// Ran only twice
Thread.Sleep(((intervalSeconds) * 1000) + 1000);
Task.WaitAll(
taskSchedulers.Select(
taskScheduler =>
Task.Run(() => taskScheduler.Tick())).ToArray(), 1000);
File.ReadAllText(semaphoreFile).Should()
.Be(TaskQueueTestFixture.SemaphoreText + TaskQueueTestFixture.SemaphoreText);
}
public async Task ItsTasksAreConsumedOnlyOnceByMultipleConsumers()
{
var numberOfJobs = 4;
var sharedTaskQueueName = nameof(ItsTasksAreConsumedOnlyOnceByMultipleConsumers);
var consumers = new[]
{
new TaskQueueTestFixture(sharedTaskQueueName),
new TaskQueueTestFixture(sharedTaskQueueName)
};
var semaphoreFiles = new List <string>();
for (int i = 0; i < numberOfJobs; ++i)
{
var path = Path.GetTempFileName();
File.Delete(path);
semaphoreFiles.Add(path);
var sharedTaskQueue = consumers[0].TaskQueue;
sharedTaskQueue.Enqueue(() => TaskQueueTestFixture.WriteSempaphore(path));
}
var tasks = new List <Task>();
for (int i = 0; i < numberOfJobs; i += consumers.Length)
{
foreach (var consumer in consumers)
{
var task = Task.Run(() => consumer.TaskQueue.ExecuteNext());
tasks.Add(task);
}
}
foreach (var task in tasks)
{
await task;
}
foreach (var semaphoreFile in semaphoreFiles)
{
File.ReadAllText(semaphoreFile).Should().Be(TaskQueueTestFixture.SemaphoreText);
}
}
public void ItContinuesListeningWhenATaskThrowsAnException()
{
var waitTime = 5000;
var taskClient = new TaskClient(TaskQueue.Redis("localhost:6379", nameof(ItContinuesListeningWhenATaskThrowsAnException)));
var semaphoreFile = Path.GetTempFileName();
taskClient.TaskQueue.Enqueue(() => Throw());
taskClient.TaskQueue.Enqueue(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile));
var task = Task.Run(() => taskClient.Listen());
Thread.Sleep(waitTime);
taskClient.CancelListen();
task.Wait();
TaskQueueTestFixture.EnsureSemaphore(semaphoreFile);
}
public void ItContinuesListeningWhenATaskThrowsAnException()
{
var waitTime = 5000;
var taskClient = new TaskClient(
TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString, nameof(ItContinuesListeningWhenATaskThrowsAnException)),
restoreScheduleFromBackup: false);
var semaphoreFile = Path.GetTempFileName();
taskClient.TaskQueue.Enqueue(() => Throw());
taskClient.TaskQueue.Enqueue(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile));
var task = Task.Run(() => taskClient.Listen());
Thread.Sleep(waitTime);
taskClient.CancelListen();
task.Wait();
TaskQueueTestFixture.EnsureSemaphore(semaphoreFile);
}
public void ItExecutesTasksOnlyOnceWhenUsingMultipleConsumers(string taskType)
{
var semaphoreFile = Path.GetTempFileName();
File.Delete(semaphoreFile);
File.Create(semaphoreFile).Close();
var intervalSeconds = 5;
var taskSchedulers = new[]
{
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false),
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false),
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false),
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false)
};
foreach (var taskScheduler in taskSchedulers)
{
if (taskType == "scheduled")
{
taskScheduler.AddScheduledTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
TimeSpan.FromSeconds(intervalSeconds), RandomTaskName);
}
if (taskType == "recurring")
{
taskScheduler.AddRecurringTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
TimeSpan.FromSeconds(intervalSeconds), RandomTaskName);
}
}
Thread.Sleep(((intervalSeconds) * 1000) + 1000);
// Ran only once
Task.WaitAll(
taskSchedulers.Select(
taskScheduler =>
Task.Run(() => taskScheduler.Tick())).ToArray(), 1000);
File.Exists(semaphoreFile).Should().Be(true);
File.ReadAllText(semaphoreFile).Should().Be(TaskQueueTestFixture.SemaphoreText);
// Ran only twice (or once if scheduled)
Thread.Sleep(((intervalSeconds) * 1000) + 1000);
Task.WaitAll(
taskSchedulers.Select(
taskScheduler =>
Task.Run(() => taskScheduler.Tick())).ToArray(), 1000);
if (taskType == "recurring")
{
File.ReadAllText(semaphoreFile).Should()
.Be(TaskQueueTestFixture.SemaphoreText + TaskQueueTestFixture.SemaphoreText);
}
if (taskType == "scheduled")
{
File.ReadAllText(semaphoreFile).Should()
.Be(TaskQueueTestFixture.SemaphoreText);
}
taskSchedulers[0].FlushBackupStorage();
}
