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);
            }
        }