//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeletesOnlyVariablesFromRemovingScope()
public virtual void testDeletesOnlyVariablesFromRemovingScope()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.DOUBLE_SUBPROCESS_MODEL);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("innerSubProcess", "subProcess").mapActivities("userTask2", "userTask2").mapActivities("compensationBoundary", "compensationBoundary").build();
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
Execution innerSubProcessExecution = rule.RuntimeService.createExecutionQuery().activityId("userTask1").singleResult();
string outerSubProcessExecutionId = ((ExecutionEntity)innerSubProcessExecution).ParentId;
rule.RuntimeService.setVariableLocal(outerSubProcessExecutionId, "outerVariable", "outerValue");
rule.RuntimeService.setVariableLocal(innerSubProcessExecution.Id, "innerVariable", "innerValue");
testHelper.completeTask("userTask1");
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count);
VariableInstance migratedVariable = testHelper.snapshotAfterMigration.getSingleVariable("innerVariable");
Assert.assertNotNull(migratedVariable);
Assert.assertEquals("innerValue", migratedVariable.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMigrateCompensationSubscriptionAddRemoveSubProcess()
public virtual void testMigrateCompensationSubscriptionAddRemoveSubProcess()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
// subProcess is not mapped
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask2", "userTask2").mapActivities("compensationBoundary", "compensationBoundary").build();
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
testHelper.completeTask("userTask1");
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
testHelper.assertEventSubscriptionMigrated("compensationHandler", "compensationHandler", null);
// and the compensation can be triggered and completed
testHelper.completeTask("userTask2");
testHelper.completeTask("compensationHandler");
testHelper.assertProcessEnded(processInstance.Id);
}
/// <summary>
/// Ensures that situations are avoided in which more tokens end up at the target gateway
/// than it has incoming flows
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testAddGatewayIncomingSequenceFlow()
public virtual void testAddGatewayIncomingSequenceFlow()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(GatewayModels.PARALLEL_GW);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(GatewayModels.PARALLEL_GW).flowNodeBuilder("fork").userTask("parallel3").connectTo("join").done());
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
testHelper.completeTask("parallel2");
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("parallel1", "parallel1").mapActivities("join", "join").build();
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
Assert.assertEquals(1, rule.TaskService.createTaskQuery().count());
Assert.assertEquals(0, rule.TaskService.createTaskQuery().taskDefinitionKey("afterJoin").count());
rule.RuntimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("join").execute();
Assert.assertEquals(0, rule.TaskService.createTaskQuery().taskDefinitionKey("afterJoin").count());
testHelper.completeTask("parallel1");
testHelper.completeTask("afterJoin");
testHelper.assertProcessEnded(processInstance.Id);
}
public virtual void historicIncidentRemainsOpenAfterMigration()
{
// Given we create a new process instance
ProcessDefinition process1 = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("calledProcess").singleResult();
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceById(process1.Id);
LockedExternalTask task = engineRule.ExternalTaskService.fetchAndLock(1, "foo").topic("foo", 1000L).execute()[0];
engineRule.ExternalTaskService.handleFailure(task.Id, "foo", "error", 0, 1000L);
Incident incidentInProcess = engineRule.RuntimeService.createIncidentQuery().processDefinitionId(process1.Id).singleResult();
// when
ProcessDefinition process2 = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("calledProcessV2").singleResult();
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(process1.Id, process2.Id).mapEqualActivities().mapActivities("ServiceTask_1p58ywb", "ServiceTask_V2").build();
engineRule.RuntimeService.newMigration(migrationPlan).processInstanceIds(processInstance.Id).execute();
// then
HistoricIncident historicIncidentAfterMigration = engineRule.HistoryService.createHistoricIncidentQuery().singleResult();
assertNotNull(historicIncidentAfterMigration);
assertNull(historicIncidentAfterMigration.EndTime);
assertTrue(historicIncidentAfterMigration.Open);
HistoricProcessInstance historicProcessInstanceAfterMigration = engineRule.HistoryService.createHistoricProcessInstanceQuery().withIncidents().incidentStatus("open").singleResult();
assertNotNull(historicProcessInstanceAfterMigration);
Incident incidentAfterMigration = engineRule.RuntimeService.createIncidentQuery().incidentId(incidentInProcess.Id).singleResult();
assertEquals(process2.Id, incidentAfterMigration.ProcessDefinitionId);
assertEquals("ServiceTask_V2", incidentAfterMigration.ActivityId);
}
public virtual void testCallActivityExternalTaskIncidentMigration()
{
// Given we create a new process instance
ProcessDefinition callingProcess = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("callingProcess").singleResult();
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceById(callingProcess.Id);
LockedExternalTask task = engineRule.ExternalTaskService.fetchAndLock(1, "foo").topic("foo", 1000L).execute()[0];
// creating an incident in the called and calling process
engineRule.ExternalTaskService.handleFailure(task.Id, "foo", "error", 0, 1000L);
Incident incidentInCallingProcess = engineRule.RuntimeService.createIncidentQuery().processDefinitionId(callingProcess.Id).singleResult();
// when
ProcessDefinition callingProcessV2 = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("callingProcessV2").singleResult();
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(callingProcess.Id, callingProcessV2.Id).mapEqualActivities().mapActivities("CallActivity", "CallActivityV2").build();
engineRule.RuntimeService.newMigration(migrationPlan).processInstanceIds(processInstance.Id).execute();
// then
Incident incidentAfterMigration = engineRule.RuntimeService.createIncidentQuery().incidentId(incidentInCallingProcess.Id).singleResult();
Assert.assertEquals(callingProcessV2.Id, incidentAfterMigration.ProcessDefinitionId);
Assert.assertEquals("CallActivityV2", incidentAfterMigration.ActivityId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testJobIncidentMigration()
public virtual void testJobIncidentMigration()
{
// Given we deploy process definitions
testHelper.deploy(FAIL_CALLED_PROC, NEW_CALLED_PROC);
ProcessDefinition failingProcess = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey(FAIL_CALLED_PROC_KEY).singleResult();
ProcessDefinition newProcess = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey(NEW_CALLED_PROC_KEY).singleResult();
//create process instance and execute job which fails
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey(FAIL_CALLED_PROC_KEY);
testHelper.executeAvailableJobs();
Incident incidentInCallingProcess = engineRule.RuntimeService.createIncidentQuery().processDefinitionId(failingProcess.Id).singleResult();
// when
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(failingProcess.Id, newProcess.Id).mapEqualActivities().mapActivities("task", "taskV2").build();
engineRule.RuntimeService.newMigration(migrationPlan).processInstanceIds(processInstance.Id).execute();
// then
Incident incidentAfterMigration = engineRule.RuntimeService.createIncidentQuery().incidentId(incidentInCallingProcess.Id).singleResult();
Assert.assertEquals(newProcess.Id, incidentAfterMigration.ProcessDefinitionId);
Assert.assertEquals("taskV2", incidentAfterMigration.ActivityId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCustomIncidentMigrationWithoutConfiguration()
public virtual void testCustomIncidentMigrationWithoutConfiguration()
{
// given
RuntimeService runtimeService = engineRule.RuntimeService;
BpmnModelInstance instance1 = Bpmn.createExecutableProcess("process1").startEvent().userTask("u1").endEvent().done();
BpmnModelInstance instance2 = Bpmn.createExecutableProcess("process2").startEvent().userTask("u2").endEvent().done();
testHelper.deploy(instance1, instance2);
ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("process1");
ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("process2");
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(processInstance1.ProcessDefinitionId, processInstance2.ProcessDefinitionId).mapActivities("u1", "u2").build();
runtimeService.createIncident("custom", processInstance1.Id, null);
// when
runtimeService.newMigration(migrationPlan).processInstanceIds(processInstance1.Id).execute();
// then
Incident incident = runtimeService.createIncidentQuery().singleResult();
assertEquals(processInstance2.ProcessDefinitionId, incident.ProcessDefinitionId);
assertEquals("custom", incident.IncidentType);
assertEquals(processInstance1.Id, incident.ExecutionId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallBpmnProcessReconfigureCallActivity()
public virtual void testCallBpmnProcessReconfigureCallActivity()
{
// given
BpmnModelInstance model = CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess");
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(model);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(model).callActivityBuilder("callActivity").calledElement("foo").done());
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then the called instance has not changed (e.g. not been migrated to a different process definition)
ProcessInstance calledInstance = rule.RuntimeService.createProcessInstanceQuery().processDefinitionKey("oneTaskProcess").singleResult();
Assert.assertNotNull(calledInstance);
// and it is possible to complete the called process instance
testHelper.completeTask("userTask");
// and the calling process instance
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallBpmnProcessSimpleMigration()
public virtual void testCallBpmnProcessSimpleMigration()
{
// given
BpmnModelInstance model = CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess");
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(model);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(model);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.assertExecutionTreeAfterMigration().hasProcessDefinitionId(targetProcessDefinition.Id).matches(describeExecutionTree(null).scope().id(testHelper.snapshotBeforeMigration.ProcessInstanceId).child("callActivity").scope().id(testHelper.getSingleExecutionIdForActivityBeforeMigration("callActivity")).done());
testHelper.assertActivityTreeAfterMigration().hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).activity("callActivity", testHelper.getSingleActivityInstanceBeforeMigration("callActivity").Id).done());
// and it is possible to complete the called process instance
testHelper.completeTask("userTask");
// and the calling process instance
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallBpmnProcessParallelMultiInstance()
public virtual void testCallBpmnProcessParallelMultiInstance()
{
// given
BpmnModelInstance model = modify(CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess")).activityBuilder("callActivity").multiInstance().parallel().cardinality("1").done();
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(model);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(model);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity#multiInstanceBody", "callActivity#multiInstanceBody").mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.assertExecutionTreeAfterMigration().hasProcessDefinitionId(targetProcessDefinition.Id).matches(describeExecutionTree(null).scope().id(testHelper.snapshotBeforeMigration.ProcessInstanceId).child(null).scope().id(testHelper.getSingleExecutionIdForActivityBeforeMigration("callActivity#multiInstanceBody")).child("callActivity").concurrent().noScope().id(testHelper.getSingleExecutionIdForActivityBeforeMigration("callActivity")).done());
testHelper.assertActivityTreeAfterMigration().hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).beginMiBody("callActivity").activity("callActivity", testHelper.getSingleActivityInstanceBeforeMigration("callActivity").Id).done());
// and the link between calling and called instance is maintained correctly
testHelper.assertSuperExecutionOfProcessInstance(rule.RuntimeService.createProcessInstanceQuery().processDefinitionKey("oneTaskProcess").singleResult().Id, testHelper.getSingleExecutionIdForActivityAfterMigration("callActivity"));
// and it is possible to complete the called process instance
testHelper.completeTask("userTask");
// and the calling process instance
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallCmmnCaseSequentialMultiInstanceRemoveMiBody()
public virtual void testCallCmmnCaseSequentialMultiInstanceRemoveMiBody()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(modify(CallActivityModels.oneCmmnCallActivityProcess("oneTaskCase")).activityBuilder("callActivity").multiInstance().sequential().cardinality("1").done());
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CallActivityModels.oneCmmnCallActivityProcess("oneTaskCase"));
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.assertExecutionTreeAfterMigration().hasProcessDefinitionId(targetProcessDefinition.Id).matches(describeExecutionTree(null).scope().id(testHelper.snapshotBeforeMigration.ProcessInstanceId).child("callActivity").scope().done());
testHelper.assertActivityTreeAfterMigration().hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).activity("callActivity", testHelper.getSingleActivityInstanceBeforeMigration("callActivity").Id).done());
// then the link between calling and called instance is maintained correctly
testHelper.assertSuperExecutionOfCaseInstance(rule.CaseService.createCaseInstanceQuery().caseDefinitionKey("oneTaskCase").singleResult().Id, testHelper.getSingleExecutionIdForActivityAfterMigration("callActivity"));
// and it is possible to complete the called case instance
CaseExecution caseExecution = rule.CaseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
testHelper.completeTask("PI_HumanTask_1");
// and the calling process instance
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
// and close the called case instance
rule.CaseService.withCaseExecution(caseExecution.CaseInstanceId).close();
testHelper.assertCaseEnded(caseExecution.CaseInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCannotMigrateAsyncActivityInstance()
public virtual void testCannotMigrateAsyncActivityInstance()
{
// given
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
BpmnModelInstance model = ProcessModels.newModel().startEvent().serviceTask("serviceTask").camundaAsyncBefore().camundaClass(typeof(SignallableServiceTaskDelegate).FullName).endEvent().done();
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(model);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(model);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("serviceTask", "serviceTask").build();
string processInstanceId = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id).Id;
testHelper.executeAvailableJobs();
// when
try
{
rule.RuntimeService.newMigration(migrationPlan).processInstanceIds(processInstanceId).execute();
Assert.fail("should fail");
}
catch (MigratingProcessInstanceValidationException e)
{
// then
assertThat(e.ValidationReport).hasActivityInstanceFailures("serviceTask", "The type of the source activity is not supported for activity instance migration");
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testIntermediateConditionalEventWithSetVariableOnEndListener()
public virtual void testIntermediateConditionalEventWithSetVariableOnEndListener()
{
// given
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(Bpmn.createExecutableProcess().startEvent().subProcess().camundaExecutionListenerClass([email protected]_Fields.EVENTNAME_END, typeof(SetVariableDelegate).FullName).embeddedSubProcess().startEvent().intermediateCatchEvent(CONDITION_ID).conditionalEventDefinition().condition(VAR_CONDITION).conditionalEventDefinitionDone().userTask(TASK_AFTER_CONDITION_ID).endEvent().subProcessDone().endEvent().done());
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(Bpmn.createExecutableProcess().startEvent().intermediateCatchEvent(CONDITION_ID).conditionalEventDefinition().condition(VAR_CONDITION).conditionalEventDefinitionDone().userTask(TASK_AFTER_CONDITION_ID).endEvent().done());
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities(CONDITION_ID, CONDITION_ID).updateEventTrigger().build();
//when sub process is removed, end listener is called and sets variable
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
testHelper.assertEventSubscriptionMigrated(CONDITION_ID, CONDITION_ID, null);
assertEquals(1, rule.RuntimeService.getVariable(processInstance.Id, VARIABLE_NAME));
//then conditional event is not triggered
assertNull(rule.TaskService.createTaskQuery().singleResult());
//when any var is set
testHelper.AnyVariable = processInstance.Id;
//then condition is satisfied, since variable is already set which satisfies condition
testHelper.completeTask(TASK_AFTER_CONDITION_ID);
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void tesConditionalEventSubProcessWithSetVariableOnStartListener()
public virtual void tesConditionalEventSubProcessWithSetVariableOnStartListener()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.ONE_TASK_PROCESS).addSubProcessTo(PROC_DEF_KEY).triggerByEvent().embeddedSubProcess().startEvent(EVENT_SUB_PROCESS_START_ID).condition(VAR_CONDITION).userTask(TASK_AFTER_CONDITION_ID).endEvent().done());
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
BpmnModelInstance targetModel = modify(Bpmn.createExecutableProcess(PROC_DEF_KEY).startEvent().subProcess(SUB_PROCESS_ID).camundaExecutionListenerClass([email protected]_Fields.EVENTNAME_START, typeof(SetVariableDelegate).FullName).embeddedSubProcess().startEvent().userTask(USER_TASK_ID).endEvent().subProcessDone().endEvent().done()).addSubProcessTo(SUB_PROCESS_ID).triggerByEvent().embeddedSubProcess().startEvent().condition(VAR_CONDITION).endEvent().done();
targetModel = modify(targetModel).addSubProcessTo(PROC_DEF_KEY).triggerByEvent().embeddedSubProcess().startEvent(EVENT_SUB_PROCESS_START_ID).condition(VAR_CONDITION).userTask(TASK_AFTER_CONDITION_ID).endEvent().done();
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(targetModel);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities(USER_TASK_ID, USER_TASK_ID).mapActivities(EVENT_SUB_PROCESS_START_ID, EVENT_SUB_PROCESS_START_ID).updateEventTrigger().build();
//when sub process is added, start listener is called and sets variable
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
testHelper.assertEventSubscriptionMigrated(EVENT_SUB_PROCESS_START_ID, EVENT_SUB_PROCESS_START_ID, null);
assertEquals(1, rule.RuntimeService.getVariable(processInstance.Id, VARIABLE_NAME));
//then conditional event is not triggered
assertEquals(USER_TASK_ID, rule.TaskService.createTaskQuery().singleResult().TaskDefinitionKey);
//when any var is set
testHelper.AnyVariable = processInstance.Id;
//then condition is satisfied, since variable is already set which satisfies condition
testHelper.completeTask(TASK_AFTER_CONDITION_ID);
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariablesInParentEventScopeStillAccessible()
public virtual void testVariablesInParentEventScopeStillAccessible()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.DOUBLE_SUBPROCESS_MODEL);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("subProcess", "outerSubProcess").mapActivities("compensationBoundary", "compensationBoundary").mapActivities("userTask2", "userTask2").build();
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
Execution subProcessExecution = rule.RuntimeService.createExecutionQuery().activityId("userTask1").singleResult();
rule.RuntimeService.setVariableLocal(subProcessExecution.Id, "foo", "bar");
testHelper.completeTask("userTask1");
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// when throwing compensation
testHelper.completeAnyTask("userTask2");
// then the variable snapshot is available
Task compensationTask = rule.TaskService.createTaskQuery().singleResult();
Assert.assertEquals("bar", rule.TaskService.getVariable(compensationTask.Id, "foo"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMigrateEventSubscriptionChangeCondition()
public virtual void testMigrateEventSubscriptionChangeCondition()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ONE_CONDITION_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(Bpmn.createExecutableProcess().startEvent().intermediateCatchEvent(NEW_CONDITION_ID).conditionalEventDefinition().condition(NEW_VAR_CONDITION).conditionalEventDefinitionDone().userTask(USER_TASK_ID).done());
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities(CONDITION_ID, NEW_CONDITION_ID).updateEventTrigger().build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
testHelper.assertEventSubscriptionMigrated(CONDITION_ID, NEW_CONDITION_ID, null);
//and var is set with value of old condition
testHelper.setVariable(processInstance.Id, VAR_NAME, "1");
//then nothing happens
assertNull(rule.TaskService.createTaskQuery().singleResult());
//when correct value is set
testHelper.setVariable(processInstance.Id, VAR_NAME, "2");
//then condition is satisfied
testHelper.completeTask(USER_TASK_ID);
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCanOnlyTriggerCompensationInParentOfRemovedScope()
public virtual void testCanOnlyTriggerCompensationInParentOfRemovedScope()
{
BpmnModelInstance sourceModel = ProcessModels.newModel().startEvent().subProcess("outerSubProcess").embeddedSubProcess().startEvent().userTask("userTask1").boundaryEvent("compensationBoundary").compensateEventDefinition().compensateEventDefinitionDone().moveToActivity("userTask1").subProcess("innerSubProcess").embeddedSubProcess().startEvent().userTask("userTask2").endEvent().subProcessDone().endEvent().subProcessDone().done();
CompensationModels.addUserTaskCompensationHandler(sourceModel, "compensationBoundary", "compensationHandler");
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(sourceModel);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(CompensationModels.COMPENSATION_TWO_TASKS_SUBPROCESS_MODEL).endEventBuilder("subProcessEnd").compensateEventDefinition().waitForCompletion(true).compensateEventDefinitionDone().done());
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("innerSubProcess", "subProcess").mapActivities("userTask2", "userTask2").mapActivities("compensationBoundary", "compensationBoundary").build();
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
testHelper.completeTask("userTask1");
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// when
testHelper.completeTask("userTask2");
// then compensation is not triggered from inside the inner sub process
// but only on process definition level
ActivityInstance activityInstance = rule.RuntimeService.getActivityInstance(processInstance.Id);
assertThat(activityInstance).hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).activity("compensationEvent").beginScope("subProcess").activity("compensationHandler").done());
}
public virtual void testMigrateWithSubTask()
{
//given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
Task task = taskService.createTaskQuery().singleResult();
Task subTask = taskService.newTask();
subTask.ParentTaskId = task.Id;
taskService.saveTask(subTask);
// when
runtimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).execute();
// then the historic sub task instance is still the same
HistoricTaskInstance historicSubTaskAfterMigration = historyService.createHistoricTaskInstanceQuery().taskId(subTask.Id).singleResult();
Assert.assertNotNull(historicSubTaskAfterMigration);
Assert.assertNull(historicSubTaskAfterMigration.ProcessDefinitionId);
Assert.assertNull(historicSubTaskAfterMigration.ProcessDefinitionKey);
Assert.assertNull(historicSubTaskAfterMigration.ExecutionId);
Assert.assertNull(historicSubTaskAfterMigration.ActivityInstanceId);
}
public virtual void testMigrateHistoryUserTaskInstance()
{
//given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.ONE_TASK_PROCESS).changeElementId("Process", "Process2").changeElementId("userTask", "userTask2"));
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
HistoricTaskInstanceQuery sourceHistoryTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
HistoricTaskInstanceQuery targetHistoryTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery().processDefinitionId(targetProcessDefinition.Id);
ActivityInstance activityInstance = runtimeService.getActivityInstance(processInstance.Id);
//when
assertEquals(1, sourceHistoryTaskInstanceQuery.count());
assertEquals(0, targetHistoryTaskInstanceQuery.count());
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
runtimeService.newMigration(migrationPlan).processInstanceQuery(sourceProcessInstanceQuery).execute();
//then
assertEquals(0, sourceHistoryTaskInstanceQuery.count());
assertEquals(1, targetHistoryTaskInstanceQuery.count());
HistoricTaskInstance instance = targetHistoryTaskInstanceQuery.singleResult();
assertEquals(targetProcessDefinition.Key, instance.ProcessDefinitionKey);
assertEquals(targetProcessDefinition.Id, instance.ProcessDefinitionId);
assertEquals("userTask2", instance.TaskDefinitionKey);
assertEquals(activityInstance.getActivityInstances("userTask")[0].Id, instance.ActivityInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDontWriteDuplicateLogOnBatchMigrationJobExecution()
public virtual void testDontWriteDuplicateLogOnBatchMigrationJobExecution()
{
// given
ProcessDefinition sourceDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceDefinition.Id);
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceDefinition.Id, targetDefinition.Id).mapEqualActivities().build();
batch = runtimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).executeAsync();
Job seedJob = managementService.createJobQuery().singleResult();
managementService.executeJob(seedJob.Id);
Job migrationJob = managementService.createJobQuery().jobDefinitionId(batch.BatchJobDefinitionId).singleResult();
// when
managementService.executeJob(migrationJob.Id);
// then
assertEquals(9, userOperationLogQuery().count());
assertEquals(2, userOperationLogQuery().operationType(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE).entityType(EntityTypes.DEPLOYMENT).count());
assertEquals(1, userOperationLogQuery().operationType(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE).entityType(EntityTypes.PROCESS_INSTANCE).count());
assertEquals(3, userOperationLogQuery().operationType(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_MIGRATE).entityType(EntityTypes.PROCESS_INSTANCE).count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMigrateHistoricIncidentAddScope()
public virtual void testMigrateHistoricIncidentAddScope()
{
// given
ProcessDefinition sourceProcess = testHelper.deployAndGetDefinition(AsyncProcessModels.ASYNC_BEFORE_USER_TASK_PROCESS);
ProcessDefinition targetProcess = testHelper.deployAndGetDefinition(AsyncProcessModels.ASYNC_BEFORE_SUBPROCESS_USER_TASK_PROCESS);
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcess.Id, targetProcess.Id).mapActivities("userTask", "userTask").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcess.Id);
Job job = managementService.createJobQuery().singleResult();
managementService.setJobRetries(job.Id, 0);
// when
runtimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).execute();
// then
ActivityInstance activityInstance = runtimeService.getActivityInstance(processInstance.Id);
HistoricIncident historicIncident = historyService.createHistoricIncidentQuery().singleResult();
Assert.assertNotNull(historicIncident);
Assert.assertEquals(activityInstance.getTransitionInstances("userTask")[0].ExecutionId, historicIncident.ExecutionId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void canCreateMigrationPlanForNoTenants()
public virtual void canCreateMigrationPlanForNoTenants()
{
// given
ProcessDefinition sharedDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
// when
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(sharedDefinition.Id, sharedDefinition.Id).mapEqualActivities().build();
// then
Assert.assertNotNull(migrationPlan);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void initTest()
public virtual void initTest()
{
runtimeService = rule.RuntimeService;
historyService = rule.HistoryService;
sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ModifiableBpmnModelInstance modifiedModel = modify(ProcessModels.ONE_TASK_PROCESS).changeElementId("Process", "Process2").changeElementId("userTask", "userTask2");
targetProcessDefinition = testHelper.deployAndGetDefinition(modifiedModel);
migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask", "userTask2").build();
runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
}
public virtual void testInitParallelMigration()
{
// given
ProcessInstance instance = rule.processInstance();
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(instance.ProcessDefinitionId, instance.ProcessDefinitionId).mapEqualActivities().build();
// when
rule.RuntimeService.newMigration(migrationPlan).processInstanceIds(instance.Id).execute();
// then the receive task messages can be correlated
rule.messageCorrelation("Message").correlateAll();
rule.assertScenarioEnded();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void canCreateMigrationPlanForSharedDefinitionsWithNoAuthenticatedTenants()
public virtual void canCreateMigrationPlanForSharedDefinitionsWithNoAuthenticatedTenants()
{
// given
ProcessDefinition sourceDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
// when
engineRule.IdentityService.setAuthentication("user", null, null);
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(sourceDefinition.Id, targetDefinition.Id).mapEqualActivities().build();
// then
Assert.assertNotNull(migrationPlan);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void canCreateMigrationPlanForDefinitionsOfAuthenticatedTenant()
public virtual void canCreateMigrationPlanForDefinitionsOfAuthenticatedTenant()
{
// given
ProcessDefinition tenant1Definition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition tenant2Definition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);
// when
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(tenant1Definition.Id, tenant2Definition.Id).mapEqualActivities().build();
// then
Assert.assertNotNull(migrationPlan);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void canCreateMigrationPlanWithDisabledTenantCheck()
public virtual void canCreateMigrationPlanWithDisabledTenantCheck()
{
// given
ProcessDefinition tenant1Definition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition tenant2Definition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);
// when
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.ProcessEngineConfiguration.TenantCheckEnabled = false;
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(tenant1Definition.Id, tenant2Definition.Id).mapEqualActivities().build();
// then
Assert.assertNotNull(migrationPlan);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testContinueProcess()
public virtual void testContinueProcess()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(TransactionModels.ONE_TASK_TRANSACTION);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(TransactionModels.ONE_TASK_TRANSACTION);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("transaction", "transaction").mapActivities("userTask", "userTask").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void canMigrateInstanceWithTenantIdToDefinitionWithoutTenantId()
public virtual void canMigrateInstanceWithTenantIdToDefinitionWithoutTenantId()
{
// given
ProcessDefinition sourceDefinition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceById(sourceDefinition.Id);
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(sourceDefinition.Id, targetDefinition.Id).mapEqualActivities().build();
// when
engineRule.RuntimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).execute();
// then
assertMigratedTo(processInstance, targetDefinition);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void canMigrateInstanceBetweenSameTenantCase2()
public virtual void canMigrateInstanceBetweenSameTenantCase2()
{
// given
ProcessDefinition sharedDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetDefinition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);
ProcessInstance processInstance = startInstanceForTenant(sharedDefinition, TENANT_ONE);
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(sharedDefinition.Id, targetDefinition.Id).mapEqualActivities().build();
// when
engineRule.RuntimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).execute();
// then
assertInstanceOfDefinition(processInstance, targetDefinition);
}
