public virtual void testScopeTaskStartBefore()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
string processInstanceId = processInstance.Id;
Batch modificationBatch = runtimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("theTask").executeAsync();
assertNotNull(modificationBatch);
executeSeedAndBatchJobs(modificationBatch);
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("theTask").activity("theTask").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).concurrent().noScope().child("theTask").scope().up().up().child(null).concurrent().noScope().child("theTask").scope().done());
assertEquals(2, taskService.createTaskQuery().count());
completeTasksInOrder("theTask", "theTask");
assertProcessEnded(processInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtParentScopeExecutionAndScopeExecutionBecomeNonScope()
public virtual void testVariableAtParentScopeExecutionAndScopeExecutionBecomeNonScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ONE_BOUNDARY_TASK);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine);
ExecutionTree scopeExecution = executionTreeBeforeMigration.getLeafExecutions("userTask")[0];
runtimeService.setVariableLocal(scopeExecution.Id, "foo", "userTaskScopeValue");
runtimeService.setVariableLocal(processInstance.Id, "foo", "processScopeValue");
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then the process scope variable was overwritten due to a compacted execution tree
Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count);
VariableInstance variable = testHelper.snapshotAfterMigration.getVariables().GetEnumerator().next();
Assert.assertEquals("userTaskScopeValue", variable.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtConcurrentExecutionAddParentScopeBecomeNonConcurrent()
public virtual void testVariableAtConcurrentExecutionAddParentScopeBecomeNonConcurrent()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.PARALLEL_TASK_AND_SUBPROCESS_PROCESS).activityBuilder("subProcess").camundaInputParameter("foo", "subProcessValue").done());
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask1", "userTask1").mapActivities("userTask2", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine);
ExecutionTree task1CcExecution = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0];
ExecutionTree 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.assertEquals(2, testHelper.snapshotAfterMigration.getVariables().Count);
IList <string> values = new List <string>();
foreach (VariableInstance variable in testHelper.snapshotAfterMigration.getVariables())
{
values.Add((string)variable.Value);
}
Assert.assertTrue(values.Contains("task1Value"));
Assert.assertTrue(values.Contains("task2Value"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtConcurrentExecutionBecomeScope()
public virtual void testVariableAtConcurrentExecutionBecomeScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_SCOPE_TASKS);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine);
ExecutionTree concurrentExecution = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0];
runtimeService.setVariableLocal(concurrentExecution.Id, "foo", 42);
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
VariableInstance beforeMigration = testHelper.snapshotBeforeMigration.getSingleVariable("foo");
ExecutionTree userTask1CCExecution = testHelper.snapshotAfterMigration.ExecutionTree.getLeafExecutions("userTask1")[0].Parent;
Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count);
testHelper.assertVariableMigratedToExecution(beforeMigration, userTask1CCExecution.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtConcurrentAndScopeExecutionBecomeNonScope()
public virtual void testVariableAtConcurrentAndScopeExecutionBecomeNonScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine);
ExecutionTree scopeExecution = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0];
ExecutionTree concurrentExecution = scopeExecution.Parent;
runtimeService.setVariableLocal(scopeExecution.Id, "foo", 42);
runtimeService.setVariableLocal(concurrentExecution.Id, "foo", 42);
// when
try
{
testHelper.migrateProcessInstance(migrationPlan, processInstance);
Assert.fail("expected exception");
}
catch (ProcessEngineException e)
{
Assert.assertThat(e.Message, CoreMatchers.containsString("The variable 'foo' exists in both, this scope" + " and concurrent local in the parent scope. Migrating to a non-scope activity would overwrite one of them."));
}
}
public virtual void testVariableAtParentScopeExecutionAndScopeExecutionBecomeNonScope()
{
// 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.GetLeafExecutions("userTask")[0];
runtimeService.SetVariableLocal(scopeExecution.Id, "foo", "userTaskScopeValue");
runtimeService.SetVariableLocal(processInstance.Id, "foo", "processScopeValue");
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the process scope variable was overwritten due to a compacted execution tree
Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables()
.Count);
var variable = testHelper.SnapshotAfterMigration.GetVariables()
.GetEnumerator()
.Current;
Assert.AreEqual("userTaskScopeValue", variable.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtScopeExecutionBecomeNonScope()
public virtual void testVariableAtScopeExecutionBecomeNonScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ONE_BOUNDARY_TASK);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine);
ExecutionTree scopeExecution = executionTreeBeforeMigration.Executions[0];
runtimeService.setVariableLocal(scopeExecution.Id, "foo", 42);
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
VariableInstance beforeMigration = testHelper.snapshotBeforeMigration.getSingleVariable("foo");
Assert.assertEquals(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();
VariableInstance variableAfterExpansion = runtimeService.createVariableInstanceQuery().singleResult();
Assert.assertNotNull(variableAfterExpansion);
Assert.assertNotSame(processInstance.Id, variableAfterExpansion.ExecutionId);
}
public virtual void testCancelInnerActivityParallelTasksAllButOne()
{
// given
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("miParallelUserTasks");
completeTasksInOrder("beforeTask");
// when
ActivityInstance tree = runtimeService.getActivityInstance(processInstance.Id);
runtimeService.createProcessInstanceModification(processInstance.Id).cancelActivityInstance(tree.getActivityInstances("miTasks")[0].Id).cancelActivityInstance(tree.getActivityInstances("miTasks")[1].Id).execute();
// then
tree = runtimeService.getActivityInstance(processInstance.Id);
assertThat(tree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).beginMiBody("miTasks").activity("miTasks").endScope().done());
// the execution tree should still be in the expected shape
ExecutionTree executionTree = ExecutionTree.forExecution(processInstance.Id, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).scope().child("miTasks").concurrent().noScope().done());
// and the process is able to complete successfully
completeTasksInOrder("miTasks", "afterTask");
assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtConcurrentExecutionInScopeActivityRemoveParentScope()
public virtual void testVariableAtConcurrentExecutionInScopeActivityRemoveParentScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(SUBPROCESS_CONCURRENT_BOUNDARY_TASKS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask1", "userTask1").mapActivities("userTask2", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine);
ExecutionTree userTask1CCExecutionBefore = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0].Parent;
runtimeService.setVariableLocal(userTask1CCExecutionBefore.Id, "foo", 42);
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
VariableInstance beforeMigration = testHelper.snapshotBeforeMigration.getSingleVariable("foo");
ExecutionTree userTask1CCExecutionAfter = testHelper.snapshotAfterMigration.ExecutionTree.getLeafExecutions("userTask1")[0].Parent;
Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count);
// 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, processInstance.Id);
}
public virtual void noHistoryUpdateOnSameStructureMigration()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK);
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 there is still one historic variable instance
Assert.AreEqual(1, historyService.CreateHistoricVariableInstanceQuery()
.Count());
// and no additional historic details
Assert.AreEqual(1, historyService.CreateHistoricDetailQuery()
.Count());
}
public virtual void testStartBeforeInnerActivityWithMiBodySequentialSubprocess()
{
// given the mi body is not yet instantiated
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("miSequentialSubprocess");
// when
ActivityInstance tree = runtimeService.getActivityInstance(processInstance.Id);
runtimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("subProcessTask").execute();
// then the mi variables should be correct
Execution leafExecution = runtimeService.createExecutionQuery().activityId("subProcessTask").singleResult();
assertNotNull(leafExecution);
assertVariable(leafExecution, "loopCounter", 0);
assertVariable(leafExecution, "nrOfInstances", 1);
assertVariable(leafExecution, "nrOfCompletedInstances", 0);
assertVariable(leafExecution, "nrOfActiveInstances", 1);
// and the trees should be correct
tree = runtimeService.getActivityInstance(processInstance.Id);
assertThat(tree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("beforeTask").beginMiBody("miSubProcess").beginScope("miSubProcess").activity("subProcessTask").endScope().done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstance.Id, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child("beforeTask").concurrent().noScope().up().child(null).concurrent().noScope().child(null).scope().child("subProcessTask").scope().done());
// and the process is able to complete successfully
completeTasksInOrder("subProcessTask", "afterTask", "beforeTask", "subProcessTask", "subProcessTask", "subProcessTask", "afterTask");
assertProcessEnded(processInstance.Id);
}
public virtual void noHistoryUpdateOnAddScopeMigration()
{
// 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 there is still one historic variable instance
Assert.AreEqual(1, historyService.CreateHistoricVariableInstanceQuery()
.Count());
// and no additional historic details
Assert.AreEqual(1, historyService.CreateHistoricDetailQuery()
.Count());
}
public virtual void testCancellationAndStartBefore()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("exclusiveGateway");
string processInstanceId = processInstance.Id;
ActivityInstance tree = runtimeService.getActivityInstance(processInstance.Id);
Batch modificationBatch = runtimeService.createProcessInstanceModification(processInstance.Id).cancelActivityInstance(getInstanceIdForActivity(tree, "task1")).startBeforeActivity("task2").executeAsync();
assertNotNull(modificationBatch);
executeSeedAndBatchJobs(modificationBatch);
ActivityInstance activityInstanceTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(activityInstanceTree);
assertEquals(processInstanceId, activityInstanceTree.ProcessInstanceId);
assertThat(activityInstanceTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("task2").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree("task2").scope().done());
completeTasksInOrder("task2");
assertProcessEnded(processInstanceId);
}
public virtual void testStartAfterActivityListenerInvocation()
{
RecorderExecutionListener.clear();
ProcessInstance instance = runtimeService.startProcessInstanceByKey("transitionListenerProcess", Variables.createVariables().putValue("listener", new RecorderExecutionListener()));
Batch modificationBatch = runtimeService.createProcessInstanceModification(instance.Id).startTransition("flow2").executeAsync();
assertNotNull(modificationBatch);
executeSeedAndBatchJobs(modificationBatch);
// transition listener should have been invoked
IList <RecorderExecutionListener.RecordedEvent> events = RecorderExecutionListener.RecordedEvents;
assertEquals(1, events.Count);
RecorderExecutionListener.RecordedEvent @event = events[0];
assertEquals("flow2", @event.TransitionId);
RecorderExecutionListener.clear();
ActivityInstance updatedTree = runtimeService.getActivityInstance(instance.Id);
assertNotNull(updatedTree);
assertEquals(instance.Id, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(instance.ProcessDefinitionId).activity("task1").activity("task2").done());
ExecutionTree executionTree = ExecutionTree.forExecution(instance.Id, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task1").concurrent().noScope().up().child("task2").concurrent().noScope().done());
completeTasksInOrder("task1", "task2", "task2");
assertProcessEnded(instance.Id);
}
public virtual void testVariableAtConcurrentExecutionBecomeScope()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ScopeTaskProcess);
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 concurrentExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0];
runtimeService.SetVariableLocal(concurrentExecution.Id, "foo", 42);
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then
var beforeMigration = testHelper.SnapshotBeforeMigration.GetSingleVariable("foo");
var userTask1CCExecution =
testHelper.SnapshotAfterMigration.ExecutionTree.GetLeafExecutions("userTask1")[0].Parent;
Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables()
.Count);
testHelper.AssertVariableMigratedToExecution(beforeMigration, userTask1CCExecution.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableAtTaskAndConcurrentExecutionAddParentScope()
public virtual void testVariableAtTaskAndConcurrentExecutionAddParentScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_SUBPROCESS_PROCESS);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask1", "userTask1").mapActivities("userTask2", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
Task task = taskService.createTaskQuery().taskDefinitionKey("userTask1").singleResult();
taskService.setVariableLocal(task.Id, "foo", 42);
runtimeService.setVariableLocal(task.ExecutionId, "foo", 52);
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
VariableInstance taskVarBeforeMigration = testHelper.snapshotBeforeMigration.getSingleTaskVariable(task.Id, "foo");
ExecutionTree userTask1ExecutionAfter = testHelper.snapshotAfterMigration.ExecutionTree.getLeafExecutions("userTask1")[0];
Assert.assertEquals(2, testHelper.snapshotAfterMigration.getVariables().Count);
testHelper.assertVariableMigratedToExecution(taskVarBeforeMigration, userTask1ExecutionAfter.Id);
}
public virtual void testVariableAtConcurrentAndScopeExecutionBecomeNonScope()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess);
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.GetLeafExecutions("userTask1")[0];
var concurrentExecution = scopeExecution.Parent;
runtimeService.SetVariableLocal(scopeExecution.Id, "foo", 42);
runtimeService.SetVariableLocal(concurrentExecution.Id, "foo", 42);
// when
try
{
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
Assert.Fail("expected exception");
}
catch (ProcessEngineException e)
{
Assert.That(e.Message,
Does.Contain("The variable 'foo' exists in both, this scope" +
" and concurrent local in the parent scope. Migrating to a non-scope activity would overwrite one of them."));
}
}
public virtual void testStartBeforeEventSubProcessInsideSubProcessTask2ShouldBeCancelled()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
string processInstanceId = processInstance.Id;
string taskId = taskService.createTaskQuery().singleResult().Id;
taskService.complete(taskId);
runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("eventSubProcess").execute();
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).beginScope("subProcess").beginScope("eventSubProcess").activity("eventSubProcessTask").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).scope().child("eventSubProcessTask").scope().done());
completeTasksInOrder("eventSubProcessTask");
assertProcessEnded(processInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCancelConcurrentExecutionInCallingProcess()
public virtual void shouldCancelConcurrentExecutionInCallingProcess()
{
// given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance parentProcessInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess("parentProcess").startEvent().parallelGateway("split").callActivity("callActivity").calledElement("subprocess").endEvent().moveToLastGateway().userTask("parentUserTask").endEvent().done();
BpmnModelInstance parentProcessInstance = Bpmn.createExecutableProcess("parentProcess").startEvent().parallelGateway("split").callActivity("callActivity").calledElement("subprocess").endEvent().moveToLastGateway().userTask("parentUserTask").endEvent().done();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance subprocessInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess("subprocess").startEvent().userTask("childUserTask").endEvent("subEnd").done();
BpmnModelInstance subprocessInstance = Bpmn.createExecutableProcess("subprocess").startEvent().userTask("childUserTask").endEvent("subEnd").done();
testHelper.deploy(parentProcessInstance, subprocessInstance);
ProcessInstance callingInstance = runtimeService.startProcessInstanceByKey("parentProcess");
ProcessInstance calledInstance = runtimeService.createProcessInstanceQuery().superProcessInstanceId(callingInstance.Id).singleResult();
// when
runtimeService.createProcessInstanceModification(calledInstance.Id).cancelAllForActivity("childUserTask").execute();
// then
ProcessInstance calledInstanceAfterModification = runtimeService.createProcessInstanceQuery().processInstanceId(calledInstance.Id).singleResult();
Assert.assertNull(calledInstanceAfterModification);
ExecutionTree executionTree = ExecutionTree.forExecution(callingInstance.Id, rule.ProcessEngine);
assertThat(executionTree).matches(describeExecutionTree("parentUserTask").scope().done());
}
public virtual void testStartBeforeEventSubProcess()
{
var processInstance = runtimeService.StartProcessInstanceByKey("process");
var ProcessInstanceId = processInstance.Id;
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("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 testStartBeforeNoneEndEvent()
{
var processInstance = runtimeService.StartProcessInstanceByKey("oneTaskProcess");
var ProcessInstanceId = processInstance.Id;
// when I start before the none end event
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.StartBeforeActivity("theEnd")
.Execute();
// then there is no effect
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.Activity("theTask")
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree("theTask")
.Scope()
.Done());
completeTasksInOrder("theTask");
AssertProcessEnded(ProcessInstanceId);
}
public virtual void testStartBeforeIntermediateCatchEvent()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
string processInstanceId = processInstance.Id;
runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("intermediateCatchEvent").execute();
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("task").activity("intermediateCatchEvent").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task").concurrent().noScope().up().child(null).concurrent().noScope().child("intermediateCatchEvent").scope().done());
ActivityInstance catchEventInstance = getChildInstanceForActivity(updatedTree, "intermediateCatchEvent");
// and there is a timer job
Job job = managementService.createJobQuery().singleResult();
assertNotNull(job);
assertEquals(catchEventInstance.ExecutionIds[0], job.ExecutionId);
completeTasksInOrder("task");
executeAvailableJobs();
assertProcessEnded(processInstanceId);
}
public virtual void testTask2AndStartBeforeNonInterruptingBoundaryEventInsideSubProcess()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
string processInstanceId = processInstance.Id;
string taskId = taskService.createTaskQuery().singleResult().Id;
taskService.complete(taskId);
runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("innerBoundaryEvent").execute();
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).beginScope("subProcess").activity("innerTask2").activity("innerTaskAfterBoundaryEvent").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).scope().child("innerTaskAfterBoundaryEvent").concurrent().noScope().up().child("innerTask2").concurrent().noScope().done());
completeTasksInOrder("innerTask2", "innerTaskAfterBoundaryEvent");
assertProcessEnded(processInstanceId);
}
public virtual void testStartBeforeCancelEndEventConcurrent()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
string processInstanceId = processInstance.Id;
Task txTask = taskService.createTaskQuery().singleResult();
assertEquals("txTask", txTask.TaskDefinitionKey);
// when I start before the cancel end event
runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("cancelEnd").execute();
// then the subprocess instance is cancelled
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("afterCancellation").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree("afterCancellation").scope().done());
Task afterCancellationTask = taskService.createTaskQuery().singleResult();
assertNotNull(afterCancellationTask);
assertFalse(txTask.Id.Equals(afterCancellationTask.Id));
assertEquals("afterCancellation", afterCancellationTask.TaskDefinitionKey);
}
public virtual void testStartBeforNoneStartEvent()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
string processInstanceId = processInstance.Id;
// when I start before the none start event
runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("theStart").execute();
// then there are two instances of "task"
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("theTask").activity("theTask").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child("theTask").concurrent().noScope().up().child("theTask").concurrent().noScope().done());
// and the process can be ended as usual
IList <Task> tasks = taskService.createTaskQuery().list();
assertEquals(2, tasks.Count);
foreach (Task task in tasks)
{
taskService.complete(task.Id);
}
assertProcessEnded(processInstanceId);
}
public virtual void testStartBeforeTimerStartEvent()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
string processInstanceId = processInstance.Id;
Job startTimerJob = managementService.createJobQuery().singleResult();
assertNotNull(startTimerJob);
// when I start before the timer start event
runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("theStart").execute();
// then there are two instances of "task"
ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId);
assertNotNull(updatedTree);
assertEquals(processInstanceId, updatedTree.ProcessInstanceId);
assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("task").activity("task").done());
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task").concurrent().noScope().up().child("task").concurrent().noScope().done());
// and there is only one timer job
Job job = managementService.createJobQuery().singleResult();
assertNotNull(job);
assertEquals(startTimerJob.Id, job.Id);
completeTasksInOrder("task", "task");
assertProcessEnded(processInstanceId);
}
public virtual void testVariableAtScopeExecutionInScopeActivity()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK);
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, beforeMigration.ExecutionId);
}
public virtual ProcessInstanceSnapshotBuilder executionTree()
{
ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine);
snapshot.ExecutionTree = executionTree;
return(this);
}
public virtual void testStartBeforeMessageStartEvent()
{
runtimeService.CorrelateMessage("startMessage");
var processInstance = runtimeService.CreateProcessInstanceQuery()
.First();
Assert.NotNull(processInstance);
var startEventSubscription = runtimeService.CreateEventSubscriptionQuery()
.First();
Assert.NotNull(startEventSubscription);
var ProcessInstanceId = processInstance.Id;
// when I start before the message start event
runtimeService.CreateProcessInstanceModification(ProcessInstanceId)
.StartBeforeActivity("theStart")
.Execute();
// then there are two instances of "task"
var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId);
Assert.NotNull(updatedTree);
Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId);
ActivityInstanceAssert.That(updatedTree)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId)
.Activity("task")
.Activity("task")
.Done());
var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine);
ExecutionAssert.That(executionTree)
.Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope()
.Child("task")
.Concurrent()
.NoScope()
.Up()
.Child("task")
.Concurrent()
.NoScope()
.Done());
// and there is only the message start event subscription
var subscription = runtimeService.CreateEventSubscriptionQuery()
.First();
Assert.NotNull(subscription);
Assert.AreEqual(startEventSubscription.Id, subscription.Id);
completeTasksInOrder("task", "task");
AssertProcessEnded(ProcessInstanceId);
}
public virtual void testVariableAtScopeAndConcurrentExecutionAddParentScope()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewaySubprocessProcess);
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(processInstance.Id, "foo", "processInstanceValue");
runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", "task1Value");
runtimeService.SetVariableLocal(userTask2CCExecutionBefore.Id, "foo", "task2Value");
//var processScopeVariable = runtimeService.CreateVariableInstanceQuery()
// //.VariableValueEquals("foo", "processInstanceValue")
// .First();
//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
Assert.AreEqual(3, testHelper.SnapshotAfterMigration.GetVariables()
.Count);
//var processScopeVariableAfterMigration =
// testHelper.SnapshotAfterMigration.GetVariable(processScopeVariable.Id);
//Assert.NotNull(processScopeVariableAfterMigration);
//Assert.AreEqual("processInstanceValue", processScopeVariableAfterMigration.Value);
//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);
}
