private void CreateTasksAndExecutionTokens()
{
var executionHelper = new ExecutionsHelper();
executionHelper.DeleteRecordsOfApplication(TestConstants.ApplicationName);
foreach (var process in _processes)
{
int drSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "DR_" + process);
int nrSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "NR_" + process);
int lsucSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "LSUC_" + process);
int lpcSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "LPC_" + process);
int lbcSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "LBC_" + process);
int ovdrSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "OV_DR_" + process);
int ovnrSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "OV_NR_" + process);
int ovlsucSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "OV_LSUC_" + process);
int ovlpcSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "OV_LPC_" + process);
int ovlbcSecondaryId = executionHelper.InsertTask(TestConstants.ApplicationName, "OV_LBC_" + process);
executionHelper.InsertAvailableExecutionToken(drSecondaryId);
executionHelper.InsertAvailableExecutionToken(nrSecondaryId);
executionHelper.InsertAvailableExecutionToken(lsucSecondaryId);
executionHelper.InsertAvailableExecutionToken(lpcSecondaryId);
executionHelper.InsertAvailableExecutionToken(lbcSecondaryId);
executionHelper.InsertAvailableExecutionToken(ovdrSecondaryId);
executionHelper.InsertAvailableExecutionToken(ovnrSecondaryId);
executionHelper.InsertAvailableExecutionToken(ovlsucSecondaryId);
executionHelper.InsertAvailableExecutionToken(ovlpcSecondaryId);
executionHelper.InsertAvailableExecutionToken(ovlbcSecondaryId);
}
}
public void If_KeepAliveMode_OneToken_MultipleTaskThreads_ThenNoDeadLocksOccur()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
// ACT
var sut = CreateSut();
var tuple = new Tuple <int, TaskExecutionRepository>(taskDefinitionId, sut);
var tasks = new List <Task>();
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
tasks.Add(Task.Factory.StartNew(RequestAndReturnTokenWithKeepAliveMode, tuple, TaskCreationOptions.LongRunning));
Task.WaitAll(tasks.ToArray());
// ASSERT
}
public async Task If_TimeOverrideMode_FiveConcurrentTasksAndFourTokensAndAllAreAvailable_ThenIsGrantFirstFourTasksAndDenyTheOther()
{
// ARRANGE
int concurrencyLimit = 4;
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId, concurrencyLimit);
var firstStartRequest = CreateOverrideStartRequest(concurrencyLimit);
var secondStartRequest = CreateOverrideStartRequest(concurrencyLimit);
var thirdStartRequest = CreateOverrideStartRequest(concurrencyLimit);
var fourthStartRequest = CreateOverrideStartRequest(concurrencyLimit);
var fifthStartRequest = CreateOverrideStartRequest(concurrencyLimit);
// ACT
var sut = CreateSut();
var firstResponse = await sut.StartAsync(firstStartRequest);
var secondResponse = await sut.StartAsync(secondStartRequest);
var thirdResponse = await sut.StartAsync(thirdStartRequest);
var fourthResponse = await sut.StartAsync(fourthStartRequest);
var fifthResponse = await sut.StartAsync(fifthStartRequest);
// ASSERT
Assert.Equal(GrantStatus.Granted, firstResponse.GrantStatus);
Assert.Equal(GrantStatus.Granted, secondResponse.GrantStatus);
Assert.Equal(GrantStatus.Granted, thirdResponse.GrantStatus);
Assert.Equal(GrantStatus.Granted, fourthResponse.GrantStatus);
Assert.Equal(GrantStatus.Denied, fifthResponse.GrantStatus);
}
public void If_TimeOverrideMode_OneToken_MultipleTaskThreads_ThenNoDeadLocksOccur()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
// ACT
var sut = CreateSut();
var tasks = new List <Task>();
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
tasks.Add(Task.Run(async() => await RequestAndReturnTokenWithTimeOverrideModeAsync(sut)));
Task.WaitAll(tasks.ToArray());
// ASSERT
}
public async Task If_TimeOverrideMode_OneTaskAndOneTokenAndIsUnavailableAndKeepAliveHasNotPassedElapsedTime_ThenIsDenied()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateOverrideStartRequest();
var secondRequest = CreateOverrideStartRequest();
// ACT
var sut = CreateSut();
var firstResponse = await sut.StartAsync(startRequest);
Thread.Sleep(5000);
var secondResponse = await sut.StartAsync(secondRequest);
// ASSERT
Assert.Equal(GrantStatus.Granted, firstResponse.GrantStatus);
Assert.NotEqual("0", firstResponse.ExecutionTokenId);
Assert.Equal(GrantStatus.Denied, secondResponse.GrantStatus);
Assert.Equal("0", secondResponse.ExecutionTokenId);
}
public void If_InUsingBlock_ThenExecutionCompletedOnEndOfBlock()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
// ACT
var executionsHelper = new ExecutionsHelper();
bool startedOk;
ExecutionTokenStatus tokenStatusAfterStart;
ExecutionTokenStatus tokenStatusAfterUsingBlock;
using (var executionContext = ClientHelper.GetExecutionContext(TestConstants.TaskName, ClientHelper.GetDefaultTaskConfigurationWithKeepAliveAndReprocessing()))
{
startedOk = executionContext.TryStart();
tokenStatusAfterStart = executionsHelper.GetExecutionTokenStatus(TestConstants.ApplicationName, TestConstants.TaskName);
}
tokenStatusAfterUsingBlock = executionsHelper.GetExecutionTokenStatus(TestConstants.ApplicationName, TestConstants.TaskName);
// ASSERT
Assert.AreEqual(true, startedOk);
Assert.AreEqual(ExecutionTokenStatus.Unavailable, tokenStatusAfterStart);
Assert.AreEqual(ExecutionTokenStatus.Available, tokenStatusAfterUsingBlock);
}
public async Task If_KeepAliveMode_OneTaskAndOneTokenAndIsUnavailableAndKeepAliveHasPassedElapsedTime_ThenIsGranted()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateKeepAliveStartRequest();
startRequest.KeepAliveDeathThreshold = new TimeSpan(0, 0, 4);
var secondRequest = CreateKeepAliveStartRequest();
secondRequest.KeepAliveDeathThreshold = new TimeSpan(0, 0, 4);
// ACT
var sut = CreateSut();
var firstResponse = await sut.StartAsync(startRequest);
executionHelper.SetKeepAlive(firstResponse.TaskExecutionId);
Thread.Sleep(6000);
var secondResponse = await sut.StartAsync(secondRequest);
// ASSERT
Assert.Equal(GrantStatus.Granted, secondResponse.GrantStatus);
Assert.NotEqual("0", secondResponse.ExecutionTokenId);
}
public void If_TimeOverrideMode_OneTaskAndOneTokenAndIsUnavailableAndGrantedDateHasPassedElapsedTime_ThenIsGranted()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateOverrideStartRequest();
startRequest.OverrideThreshold = new TimeSpan(0, 0, 5);
var secondRequest = CreateOverrideStartRequest();
secondRequest.OverrideThreshold = new TimeSpan(0, 0, 5);
// ACT
var sut = CreateSut();
var firstResponse = sut.Start(startRequest);
Thread.Sleep(6000);
var secondResponse = sut.Start(secondRequest);
// ASSERT
Assert.AreEqual(GrantStatus.Granted, firstResponse.GrantStatus);
Assert.AreEqual(GrantStatus.Granted, secondResponse.GrantStatus);
Assert.AreNotEqual("0", secondResponse.ExecutionTokenId);
}
public void Initialize()
{
_executionHelper = new ExecutionsHelper();
_executionHelper.DeleteRecordsOfApplication(TestConstants.ApplicationName);
_blocksHelper = new BlocksHelper();
_blocksHelper.DeleteBlocks(TestConstants.ApplicationName);
_taskDefinitionId = _executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
_executionHelper.InsertAvailableExecutionToken(_taskDefinitionId);
}
public When_GetRangeBlocksFromExecutionContext()
{
_blocksHelper = new BlocksHelper();
_blocksHelper.DeleteBlocks(TestConstants.ApplicationName);
_executionHelper = new ExecutionsHelper();
_executionHelper.DeleteRecordsOfApplication(TestConstants.ApplicationName);
_taskDefinitionId = _executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
_executionHelper.InsertAvailableExecutionToken(_taskDefinitionId);
}
public When_FindDeadBlocks()
{
_blocksHelper = new BlocksHelper();
_blocksHelper.DeleteBlocks(TestConstants.ApplicationName);
_executionHelper = new ExecutionsHelper();
_executionHelper.DeleteRecordsOfApplication(TestConstants.ApplicationName);
_taskDefinitionId = _executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
_executionHelper.InsertAvailableExecutionToken(_taskDefinitionId);
TaskRepository.ClearCache();
}
public void If_KeepAliveMode_OneTaskAndOneTokenAndIsAvailable_ThenIsGranted()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateKeepAliveStartRequest();
// ACT
var sut = CreateSut();
var response = sut.Start(startRequest);
// ASSERT
Assert.AreEqual(GrantStatus.Granted, response.GrantStatus);
Assert.AreNotEqual("0", response.ExecutionTokenId);
}
public async Task If_TimeOverrideMode_OneTaskAndOneTokenAndIsAvailable_ThenIsGranted()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateOverrideStartRequest();
// ACT
var sut = CreateSut();
var response = await sut.StartAsync(startRequest);
// ASSERT
Assert.Equal(GrantStatus.Granted, response.GrantStatus);
Assert.NotEqual("0", response.ExecutionTokenId);
}
public async Task If_TimeOverrideMode_ThenReturnsValidDataValues()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateOverrideStartRequest();
// ACT
var sut = CreateSut();
var response = await sut.StartAsync(startRequest);
// ASSERT
Assert.True(response.TaskExecutionId != "0");
Assert.True(response.StartedAt > DateTime.MinValue);
}
public void If_KeepAlive_ThenKeepAliveContinuesUntilExecutionContextDies()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
// ACT
StartContextWithoutUsingOrComplete();
GC.Collect(0, GCCollectionMode.Forced); // referenceless context is collected
Thread.Sleep(6000);
// ASSERT
var expectedLastKeepAliveMax = DateTime.UtcNow.AddSeconds(-5);
var lastKeepAlive = executionHelper.GetLastKeepAlive(taskDefinitionId);
Assert.IsTrue(lastKeepAlive < expectedLastKeepAliveMax);
}
public async Task If_KeepAliveMode_OneTokenExistsAndConcurrencyLimitIsUnlimited_ThenRemoveAvailableTokenAndCreateOneNewUnlimitedToken()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateKeepAliveStartRequest(-1);
// ACT
var sut = CreateSut();
await sut.StartAsync(startRequest);
// ASSERT
var tokensList = executionHelper.GetExecutionTokens(TestConstants.ApplicationName, TestConstants.TaskName);
Assert.Equal(1, tokensList.Tokens.Count(x => x.Status == ExecutionTokenStatus.Unlimited));
}
public void If_TimeOverrideMode_TwoConcurrentTasksAndOneTokenAndIsAvailable_ThenIsGrantFirstTaskAndDenyTheOther()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var firstStartRequest = CreateOverrideStartRequest();
var secondStartRequest = CreateOverrideStartRequest();
// ACT
var sut = CreateSut();
var firstResponse = sut.Start(firstStartRequest);
var secondResponse = sut.Start(secondStartRequest);
// ASSERT
Assert.AreEqual(GrantStatus.Granted, firstResponse.GrantStatus);
Assert.AreEqual(GrantStatus.Denied, secondResponse.GrantStatus);
}
public void If_KeepAliveMode_OneTokenExistsAndConcurrencyLimitIsFour_ThenCreateThreeNewTokens()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var startRequest = CreateKeepAliveStartRequest(4);
// ACT
var sut = CreateSut();
sut.Start(startRequest);
// ASSERT
var tokensList = executionHelper.GetExecutionTokens(TestConstants.ApplicationName, TestConstants.TaskName);
Assert.AreEqual(1, tokensList.Tokens.Count(x => x.Status == ExecutionTokenStatus.Unavailable));
Assert.AreEqual(3, tokensList.Tokens.Count(x => x.Status == ExecutionTokenStatus.Available));
}
public void If_KeepAliveMode_TwoSequentialTasksAndOneTokenAndIsAvailable_ThenIsGrantFirstTaskAndThenGrantTheOther()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var firstStartRequest = CreateKeepAliveStartRequest();
var secondStartRequest = CreateKeepAliveStartRequest();
// ACT
var sut = CreateSut();
var firstStartResponse = sut.Start(firstStartRequest);
var firstCompleteRequest = new TaskExecutionCompleteRequest(new TaskId(TestConstants.ApplicationName, TestConstants.TaskName), firstStartResponse.TaskExecutionId, firstStartResponse.ExecutionTokenId);
var firstCompleteResponse = sut.Complete(firstCompleteRequest);
var secondStartResponse = sut.Start(secondStartRequest);
// ASSERT
Assert.AreEqual(GrantStatus.Granted, firstStartResponse.GrantStatus);
Assert.AreEqual(GrantStatus.Granted, secondStartResponse.GrantStatus);
}
public async Task If_KeepAliveMode_TwoConcurrentTasksAndOneTokenAndIsAvailable_ThenIsGrantFirstTaskAndDenyTheOther()
{
// ARRANGE
var executionHelper = new ExecutionsHelper();
var taskDefinitionId = executionHelper.InsertTask(TestConstants.ApplicationName, TestConstants.TaskName);
executionHelper.InsertAvailableExecutionToken(taskDefinitionId);
var firstStartRequest = CreateKeepAliveStartRequest();
var secondStartRequest = CreateKeepAliveStartRequest();
// ACT
var sut = CreateSut();
var firstResponse = await sut.StartAsync(firstStartRequest);
await sut.SendKeepAliveAsync(CreateKeepAliveRequest(TestConstants.ApplicationName, TestConstants.TaskName, firstResponse.TaskExecutionId, firstResponse.ExecutionTokenId));
var secondResponse = await sut.StartAsync(secondStartRequest);
// ASSERT
Assert.Equal(GrantStatus.Granted, firstResponse.GrantStatus);
Assert.Equal(GrantStatus.Denied, secondResponse.GrantStatus);
}
