public void Task_With_PreventConcurrentTaskExecutionAttribute_UnableToAcquireLock_Verify_InteractsWithDistributedMutex()
{
var distributedMutex = new DistributedMutexStub();
using (var context = ApplicationContext.Create(application => application
.ConfigureForUnitTest()
.Services(services => services
.Advanced(advanced => advanced
.Register <IRuntimeSettings>(kernel => new InMemoryRuntimeSettings()
.Set("ConcurrentTaskExecution.PreventConcurrentTaskExecutionOnAllTasks", "false"))
.Register <IDistributedMutex>(kernel => distributedMutex)))
.Tasks(tasks => tasks
.Task <ThrowIfStartsTask>())))
{
var runner = context.Resolve <ITaskRunner>();
var factory = context.Resolve <ITaskFactory>();
// Create an existing lock based on the actual task
distributedMutex.SimulateLockFromTask <ThrowIfStartsTask>();
ITask task = factory.Get <ThrowIfStartsTask>();
var exception = Assert.Throws <TaskExecutionFailedException>(() => runner.Execute(task));
Assert.IsNotNull(exception.InnerException);
Assert.IsInstanceOf <TaskExecutionLockNotAcquiredException>(exception.InnerException);
Assert.IsNotNull(exception.InnerException.InnerException);
Assert.IsInstanceOf <DistributedMutexStub.IsLockedException>(exception.InnerException.InnerException);
}
}
public void Task_With_PreventConcurrentTaskExecutionAttribute_ReturnNullExceptionHandler_Verify_InteractsWithDistributedMutex()
{
var distributedMutex = new DistributedMutexStub();
using (var context = ApplicationContext.Create(application => application
.ConfigureForUnitTest()
.Services(services => services
.Advanced(advanced => advanced
.Register <IRuntimeSettings>(kernel => new InMemoryRuntimeSettings()
.Set("ConcurrentTaskExecution.PreventConcurrentTaskExecutionOnAllTasks", "false"))
.Register <IDistributedMutex>(kernel => distributedMutex)))
.Tasks(tasks => tasks
.Task <ReturnNullOnSyncExceptionTask>()
.ConcurrentTaskExecution(concurrentTaskExecution => concurrentTaskExecution
.AddExceptionHandler <ReturnNullExceptionHandler>()))))
{
var runner = context.Resolve <ITaskRunner>();
var factory = context.Resolve <ITaskFactory>();
// Create an existing lock based on the actual task
distributedMutex.SimulateLockFromTask <ReturnNullOnSyncExceptionTask>();
ITask task = factory.Get <ReturnNullOnSyncExceptionTask>();
runner.Execute(task);
}
}
public void RunSameTaskInParallel_Verify_OneTaskThrows()
{
var distributedMutex = new DistributedMutexStub();
var cancellationTokenSource = new CancellationTokenSource();
var synchronizationContext = new SynchronizationContext(cancellationTokenSource);
using (var context = ApplicationContext.Create(application => application
.ConfigureForUnitTest()
.Services(services => services
.Advanced(advanced => advanced
.Register(kernel => synchronizationContext)
.Register <IRuntimeSettings>(kernel => new InMemoryRuntimeSettings()
.Set("ConcurrentTaskExecution.PreventConcurrentTaskExecutionOnAllTasks", "true"))
.Register <IDistributedMutex>(kernel => distributedMutex)))
.Tasks(tasks => tasks
.Task <SomeTask>())))
{
var runner = context.Resolve <ITaskRunner>();
var factory = context.Resolve <ITaskFactory>();
var taskA = System.Threading.Tasks.Task.Factory.StartNew(() =>
runner.Execute(factory.Get <SomeTask>()), cancellationTokenSource.Token);
var taskB = System.Threading.Tasks.Task.Factory.StartNew(() =>
runner.Execute(factory.Get <SomeTask>()), cancellationTokenSource.Token);
cancellationTokenSource.CancelAfter(100);
try
{
System.Threading.Tasks.Task.WaitAll(taskA, taskB);
}
catch (AggregateException)
{
}
var tasks = new[] { taskA, taskB };
var failedTasks = tasks.Where(x => x.Exception != null).ToArray();
Assert.That(failedTasks.Length, Is.EqualTo(1));
Assert.That(((Exception)failedTasks[0].Exception).AggregateMessages(), Does.Contain("Unable to acquire lock 'SomeTask'"));
var completedTasks = tasks.Where(x => x.Status == TaskStatus.RanToCompletion).ToArray();
Assert.That(completedTasks.Length, Is.EqualTo(1));
}
}
