public virtual void testVariableAtScopeAndConcurrentExecutionRemoveParentScope()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewaySubprocessProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask1", "userTask1")
.MapActivities("userTask2", "userTask2")
.Build();
var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine);
var userTask1CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0];
var userTask2CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask2")[0];
var subProcessExecution = userTask1CCExecutionBefore.Parent;
runtimeService.SetVariableLocal(subProcessExecution.Id, "foo", "subProcessValue");
runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", "task1Value");
runtimeService.SetVariableLocal(userTask2CCExecutionBefore.Id, "foo", "task2Value");
//var task1Variable = runtimeService.CreateVariableInstanceQuery()
// //.VariableValueEquals("foo", "task1Value")
// .First();
//var task2Variable = runtimeService.CreateVariableInstanceQuery()
// //.VariableValueEquals("foo", "task2Value")
// .First();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the scope variable instance has been overwritten during compaction (conform to prior behavior);
// although this is tested here, changing this behavior may be ok in the future
var variables = testHelper.SnapshotAfterMigration.GetVariables();
Assert.AreEqual(2, variables.Count);
//var task1VariableAfterMigration = testHelper.SnapshotAfterMigration.GetVariable(task1Variable.Id);
//Assert.NotNull(task1VariableAfterMigration);
//Assert.AreEqual("task1Value", task1VariableAfterMigration.Value);
//var task2VariableAfterMigration = testHelper.SnapshotAfterMigration.GetVariable(task2Variable.Id);
//Assert.NotNull(task2VariableAfterMigration);
//Assert.AreEqual("task2Value", task2VariableAfterMigration.Value);
}
public virtual void testStartBeforeNonInterruptingEventSubProcessInsideSubProcessTask2ShouldStay()
{
var processInstance = runtimeService.StartProcessInstanceByKey("process");
var ProcessInstanceId = processInstance.Id;
var taskId = taskService.CreateTaskQuery()
.First()
.Id;
taskService.Complete(taskId);
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.StartBeforeActivity("eventSubProcess")
.Execute();
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.BeginScope("subProcess")
.Activity("task2")
.BeginScope("eventSubProcess")
.Activity("eventSubProcessTask")
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope()
.Child(null)
.Scope()
.Child("task2")
.Concurrent()
.NoScope()
.Up()
.Child(null)
.Concurrent()
.NoScope()
.Child("eventSubProcessTask")
.Scope()
.Done());
completeTasksInOrder("task2", "eventSubProcessTask");
AssertProcessEnded(ProcessInstanceId);
}
public virtual void testNonInterruptingEventInCombinationWithUserTaskInsideSubProcess()
{
// given
string ProcessInstanceId = runtimeService.StartProcessInstanceByKey("process").Id;
// when (1)
runtimeService.CorrelateMessage("firstMessage");
// then (1)
Assert.AreEqual(2, taskService.CreateTaskQuery().Count());
ITask task1 = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "task1").First();
Assert.NotNull(task1);
ITask innerTask = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "innerTask").First();
Assert.NotNull(innerTask);
ExecutionTree executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope().Child(null).Scope().Child("task1").NoScope().Concurrent().Up().Child(null).NoScope().Concurrent().Child("innerTask").Scope().Done());
// when (2)
taskService.Complete(innerTask.Id);
// then (2)
Assert.AreEqual(2, taskService.CreateTaskQuery().Count());
task1 = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "task1").First();
Assert.NotNull(task1);
ITask task2 = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "task2").First();
Assert.NotNull(task2);
Assert.AreEqual(0, runtimeService.CreateEventSubscriptionQuery().Count());
executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope().Child(null).Scope().Child("task1").NoScope().Concurrent().Up().Child("task2").NoScope().Concurrent().Done());
taskService.Complete(task1.Id);
taskService.Complete(task2.Id);
AssertProcessEnded(ProcessInstanceId);
}
public virtual void testAddScopeWithInputMappingAndVariableOnConcurrentExecutions()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(ProcessModels.ParallelGatewaySubprocessProcess)
//.ActivityBuilder("subProcess")
//.CamundaInputParameter("foo", "inputOutputValue")
//.Done()
);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask1", "userTask1")
.MapActivities("userTask2", "userTask2")
.Build();
var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine);
var userTask1CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0];
var userTask2CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask2")[0];
runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", "customValue");
runtimeService.SetVariableLocal(userTask2CCExecutionBefore.Id, "foo", "customValue");
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the scope variable instance has been overwritten during compaction (conform to prior behavior);
// although this is tested here, changing this behavior may be ok in the future
var variables = testHelper.SnapshotAfterMigration.GetVariables();
Assert.AreEqual(2, variables.Count);
foreach (var variable in variables)
{
Assert.AreEqual("customValue", variable.Value);
}
var subProcessExecution =
testHelper.SnapshotAfterMigration.ExecutionTree.GetLeafExecutions("userTask2")[0].Parent;
Assert.NotNull(testHelper.SnapshotAfterMigration.GetSingleVariable(subProcessExecution.Id, "foo"));
}
public virtual void testVariableAtConcurrentExecutionAddParentScopeBecomeNonConcurrent()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(ProcessModels.ParallelTaskAndSubprocessProcess)
//.ActivityBuilder("subProcess")
//.CamundaInputParameter("foo", "subProcessValue")
//.Done()
);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask1", "userTask1")
.MapActivities("userTask2", "userTask2")
.Build();
var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine);
var task1CcExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0];
var task2CcExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask2")[0];
runtimeService.SetVariableLocal(task1CcExecution.Id, "foo", "task1Value");
runtimeService.SetVariableLocal(task2CcExecution.Id, "foo", "task2Value");
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the io mapping variable was overwritten due to a compacted execution tree
Assert.AreEqual(2, testHelper.SnapshotAfterMigration.GetVariables()
.Count);
IList <string> values = new List <string>();
foreach (var variable in testHelper.SnapshotAfterMigration.GetVariables())
{
values.Add((string)variable.Value);
}
Assert.True(values.Contains("task1Value"));
Assert.True(values.Contains("task2Value"));
}
public virtual void testMultipleNonInterruptingInEmbeddedSubprocess()
{
IProcessInstance processInstance = runtimeService.StartProcessInstanceByKey("process");
// the process instance must have a message event subscription:
IExecution subProcess = runtimeService.CreateExecutionQuery() /*.MessageEventSubscriptionName("newMessage")*/.First();
Assert.NotNull(subProcess);
Assert.AreEqual(1, CreateEventSubscriptionQuery().Count());
ITask subProcessTask = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "subProcessTask").First();
Assert.NotNull(subProcessTask);
// start event sub process multiple times
for (int i = 1; i < 3; i++)
{
runtimeService.MessageEventReceived("newMessage", subProcess.Id);
// check that now i event sub process tasks exist
IList <ITask> eventSubProcessTasks = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "eventSubProcessTask").ToList();
Assert.AreEqual(i, eventSubProcessTasks.Count);
}
ExecutionTree executionTree = ExecutionTree.ForExecution(processInstance.Id, ProcessEngine);
// check that the parent execution of the event sub process task execution is the event
// sub process execution
ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope().Child(null)
.Scope().Child("subProcessTask").Concurrent().NoScope().Up().Child(null).Concurrent().NoScope().Child("eventSubProcessTask")
.Scope().Up().Up().Child(null).Concurrent().NoScope().Child("eventSubProcessTask").Scope().Done());
// complete sub process task
taskService.Complete(subProcessTask.Id);
// after complete the sub process task all task should be deleted because of the terminating end event
Assert.AreEqual(0, taskService.CreateTaskQuery().Count());
// and the process instance should be ended
Assert.AreEqual(0, runtimeService.CreateProcessInstanceQuery().Count());
}
public virtual void testTask1AndStartBeforeTaskAfterNonInterruptingBoundaryEventInsideSubProcess()
{
var processInstance = runtimeService.StartProcessInstanceByKey("process");
var ProcessInstanceId = processInstance.Id;
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.StartBeforeActivity("innerTaskAfterBoundaryEvent")
.Execute();
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.BeginScope("subProcess")
.Activity("innerTask1")
.Activity("innerTaskAfterBoundaryEvent")
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope()
.Child(null)
.Scope()
.Child("innerTaskAfterBoundaryEvent")
.Concurrent()
.NoScope()
.Up()
.Child(null)
.Concurrent()
.NoScope()
.Child("innerTask1")
.Scope()
.Done());
completeTasksInOrder("innerTask1", "innerTaskAfterBoundaryEvent", "innerTask2");
AssertProcessEnded(ProcessInstanceId);
}
public virtual void testStartBeforeCancelEndEventConcurrent()
{
var processInstance = runtimeService.StartProcessInstanceByKey("process");
var ProcessInstanceId = processInstance.Id;
var txTask = taskService.CreateTaskQuery()
.First();
Assert.AreEqual("txTask", txTask.TaskDefinitionKey);
// when I start before the cancel end event
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.StartBeforeActivity("cancelEnd")
.Execute();
// then the subprocess instance is cancelled
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.Activity("afterCancellation")
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree("afterCancellation")
.Scope()
.Done());
var afterCancellationTask = taskService.CreateTaskQuery()
.First();
Assert.NotNull(afterCancellationTask);
Assert.IsFalse(txTask.Id.Equals(afterCancellationTask.Id));
Assert.AreEqual("afterCancellation", afterCancellationTask.TaskDefinitionKey);
}
public virtual void testNonInterruptingWithParallelForkInsideEmbeddedSubProcess()
{
IProcessInstance processInstance = runtimeService.StartProcessInstanceByKey("process");
runtimeService.MessageEventReceived("newMessage", runtimeService.CreateEventSubscriptionQuery().First().ExecutionId);
ExecutionTree executionTree = ExecutionTree.ForExecution(processInstance.Id, ProcessEngine);
ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope().Child(null).Scope().Child("firstUserTask").Concurrent().NoScope().Up().Child("secondUserTask")
.Concurrent().NoScope().Up().Child(null).Concurrent().NoScope().Child("eventSubProcessTask").Done());
IList <ITask> tasks = taskService.CreateTaskQuery().ToList();
foreach (ITask task in tasks)
{
taskService.Complete(task.Id);
}
AssertProcessEnded(processInstance.Id);
}
public virtual void testVariableAtScopeExecutionBecomeNonScope()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapEqualActivities()
.Build();
var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine);
var scopeExecution = executionTreeBeforeMigration.Executions[0];
runtimeService.SetVariableLocal(scopeExecution.Id, "foo", 42);
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then
var beforeMigration = testHelper.SnapshotBeforeMigration.GetSingleVariable("foo");
Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables()
.Count);
testHelper.AssertVariableMigratedToExecution(beforeMigration, processInstance.Id);
// and the variable is concurrent local, i.E. expands on tree expansion
runtimeService.CreateProcessInstanceModification(processInstance.Id)
.StartBeforeActivity("userTask")
.Execute();
var variableAfterExpansion = runtimeService.CreateVariableInstanceQuery()
.First();
Assert.NotNull(variableAfterExpansion);
Assert.AreNotSame(processInstance.Id, variableAfterExpansion.ExecutionId);
}
public virtual void testVariableAtConcurrentExecutionInScopeActivityAddParentScope()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(SUBPROCESS_CONCURRENT_BOUNDARY_TASKS);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask1", "userTask1")
.MapActivities("userTask2", "userTask2")
.Build();
var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine);
var userTask1CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0].Parent;
runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", 42);
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then
var beforeMigration = testHelper.SnapshotBeforeMigration.GetSingleVariable("foo");
var userTask1CCExecutionAfter =
testHelper.SnapshotAfterMigration.ExecutionTree.GetLeafExecutions("userTask1")[0].Parent;
Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables()
.Count);
var subProcessInstance = testHelper.GetSingleActivityInstanceAfterMigration("subProcess");
// for variables at concurrent executions that are parent of a leaf-scope-execution, the activity instance is
// the activity instance id of the parent activity instance (which is probably a bug)
testHelper.AssertVariableMigratedToExecution(beforeMigration, userTask1CCExecutionAfter.Id,
subProcessInstance.Id);
}
public virtual void testStartBeforeTaskInsideEventSubProcessAndCancelTaskOutsideEventSubProcess()
{
var processInstance = runtimeService.StartProcessInstanceByKey("process");
var ProcessInstanceId = processInstance.Id;
var tree = runtimeService.GetActivityInstance(processInstance.Id);
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.CancelActivityInstance(getInstanceIdForActivity(tree, "task1"))
.StartBeforeActivity("eventSubProcessTask")
.Execute();
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.BeginScope("eventSubProcess")
.Activity("eventSubProcessTask")
.EndScope()
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope()
.Child("eventSubProcessTask")
.Scope()
.Done());
completeTasksInOrder("eventSubProcessTask");
AssertProcessEnded(ProcessInstanceId);
}
public virtual void testStartBeforeCancelEndEvent()
{
var processInstance = runtimeService.StartProcessInstanceByKey("process");
var ProcessInstanceId = processInstance.Id;
// complete the transaction subprocess once
var txTask = taskService.CreateTaskQuery()
.First();
Assert.AreEqual("txTask", txTask.TaskDefinitionKey);
taskService.Complete(txTask.Id, ESS.FW.Bpm.Engine.Variable.Variables.CreateVariables()
.PutValue("success", true));
var afterSuccessTask = taskService.CreateTaskQuery()
.First();
Assert.AreEqual("afterSuccess", afterSuccessTask.TaskDefinitionKey);
// when I start before the cancel end event
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.StartBeforeActivity("cancelEnd")
.Execute();
// then a new subprocess instance is created and immediately cancelled
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.Activity("afterCancellation")
.Activity("afterSuccess")
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope()
.Child("afterCancellation")
.Concurrent()
.NoScope()
.Up()
.Child("afterSuccess")
.Concurrent()
.NoScope()
.Up()
.Child("tx")
.Scope()
.EventScope()
.Done());
// the compensation for the completed tx has not been triggered
Assert.AreEqual(0, taskService.CreateTaskQuery(c => c.TaskDefinitionKeyWithoutCascade == "undoTxTask")
.Count());
// complete the process
var afterCancellationTask = taskService.CreateTaskQuery(c => c.TaskDefinitionKeyWithoutCascade == "afterCancellation")
.First();
Assert.NotNull(afterCancellationTask);
taskService.Complete(afterCancellationTask.Id);
taskService.Complete(afterSuccessTask.Id);
AssertProcessEnded(ProcessInstanceId);
}
