public virtual void testNotMigrateBoundaryEventsOfDifferentType()
{
var sourceDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
////.Message(MESSAGE_NAME)
//.Done()
));
var targetDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
//.Signal(SIGNAL_NAME)
//.Done()
);
try
{
runtimeService.CreateMigrationPlan(sourceDefinition.Id, targetDefinition.Id)
.MapActivities("userTask", "userTask")
.MapActivities("boundary", "boundary")
.Build();
Assert.Fail("Should not succeed");
}
catch (MigrationPlanValidationException e)
{
MigrationPlanValidationReportAssert.That(e.ValidationReport)
.HasInstructionFailures("boundary",
"Events are not of the same type (boundaryMessage != boundarySignal)");
}
}
public virtual void testMigrateMessageBoundaryEventKeepTrigger()
{
// given
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
////.Message(MESSAGE_NAME)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Message("new" + MESSAGE_NAME)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
IDictionary <string, string> activities = new Dictionary <string, string>();
activities[USER_TASK_ID] = USER_TASK_ID;
activities[BOUNDARY_ID] = BOUNDARY_ID;
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionMigrated(BOUNDARY_ID, BOUNDARY_ID, MESSAGE_NAME);
// and no event subscription for the new message name exists
var eventSubscription = rule.RuntimeService.CreateEventSubscriptionQuery(c => c.EventName == "new" + MESSAGE_NAME)
.First();
Assert.IsNull(eventSubscription);
Assert.AreEqual(1, rule.RuntimeService.CreateEventSubscriptionQuery()
.Count());
// and it is possible to trigger the event with the old message name and successfully complete the migrated instance
rule.ProcessEngine.RuntimeService.CorrelateMessage(MESSAGE_NAME);
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testCallBpmnProcessSequentialMultiInstanceRemoveMiBody()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess"))
//.ActivityBuilder("callActivity")
//.MultiInstance()
//.Sequential()
//.Cardinality("1")
//.Done()
);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("callActivity", "callActivity")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertExecutionTreeAfterMigration()
.HasProcessDefinitionId(targetProcessDefinition.Id)
.Matches(ExecutionAssert.DescribeExecutionTree(null)
.Scope()
.Id(testHelper.SnapshotBeforeMigration.ProcessInstanceId)
.Child("callActivity")
.Scope()
.Done());
testHelper.AssertActivityTreeAfterMigration()
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(targetProcessDefinition.Id)
.Activity("callActivity", testHelper.GetSingleActivityInstanceBeforeMigration("callActivity")
.Id)
.Done());
// then the link between calling and called instance is maintained correctly
testHelper.AssertSuperExecutionOfProcessInstance(rule.RuntimeService.CreateProcessInstanceQuery()
////.SetProcessDefinitionKey("oneTaskProcess")
.First()
.Id, testHelper.GetSingleExecutionIdForActivityAfterMigration("callActivity"));
// then it is possible to complete the called process instance
testHelper.CompleteTask("userTask");
// and the calling process instance
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testRemoveIncidentForJob()
{
// given
var sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
.UserTaskBuilder("userTask")
.BoundaryEvent("boundary")
.TimerWithDate(TIMER_DATE)
.ServiceTask("failingTask")
.CamundaClass("api.Runtime.FailingDelegate")
.EndEvent()
.Done();
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(sourceProcess)
.ChangeElementId("userTask", "newUserTask")
.ChangeElementId("boundary", "newBoundary");
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
// a timer job exists
var jobBeforeMigration = rule.ManagementService.CreateJobQuery()
.First();
Assert.NotNull(jobBeforeMigration);
// if the timer job is triggered the failing delegate fails and an incident is created
executeJob(jobBeforeMigration);
var incidentBeforeMigration = rule.RuntimeService.CreateIncidentQuery()
.First();
Assert.AreEqual("boundary", incidentBeforeMigration.ActivityId);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "newUserTask")
.Build();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the incident was removed
var jobAfterMigration = rule.ManagementService.CreateJobQuery(c => c.Id == jobBeforeMigration.Id)
.First();
Assert.IsNull(jobAfterMigration);
Assert.AreEqual(0, rule.RuntimeService.CreateIncidentQuery()
.Count());
}
public virtual void testMigrateTimerBoundaryEventKeepTrigger()
{
// given
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.TimerWithDuration("PT5S")
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.TimerWithDuration("PT10M")
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
IDictionary <string, string> activities = new Dictionary <string, string>();
activities[USER_TASK_ID] = USER_TASK_ID;
activities[BOUNDARY_ID] = BOUNDARY_ID;
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertJobMigrated(BOUNDARY_ID, BOUNDARY_ID, TimerExecuteNestedActivityJobHandler.TYPE);
// and it is possible to trigger the event and successfully complete the migrated instance
var managementService = rule.ManagementService;
var job = managementService.CreateJobQuery()
.First();
managementService.ExecuteJob(job.Id);
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testIncident()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS)
.ChangeElementId("externalTask", "newExternalTask"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("externalTask", "newExternalTask")
.Build();
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var externalTask = rule.ExternalTaskService.CreateExternalTaskQuery()
.First();
rule.ExternalTaskService.SetRetries(externalTask.Id, 0);
var incidentBeforeMigration = rule.RuntimeService.CreateIncidentQuery()
.First();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the incident has migrated
var incidentAfterMigration = rule.RuntimeService.CreateIncidentQuery()
.First();
Assert.NotNull(incidentAfterMigration);
Assert.AreEqual(incidentBeforeMigration.Id, incidentAfterMigration.Id);
Assert.AreEqual(IncidentFields.ExternalTaskHandlerType, incidentAfterMigration.IncidentType);
Assert.AreEqual(externalTask.Id, incidentAfterMigration.Configuration);
Assert.AreEqual("newExternalTask", incidentAfterMigration.ActivityId);
Assert.AreEqual(targetProcessDefinition.Id, incidentAfterMigration.ProcessDefinitionId);
Assert.AreEqual(externalTask.ExecutionId, incidentAfterMigration.ExecutionId);
// and it is possible to complete the process
rule.ExternalTaskService.SetRetries(externalTask.Id, 1);
var task = fetchAndLockSingleTask(ExternalTaskModels.TOPIC);
rule.ExternalTaskService.Complete(task.Id, WORKER_ID);
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testUpdateEventTimer()
{
// given
ClockTestUtil.SetClockToDateWithoutMilliseconds();
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.TimerWithDate(TIMER_DATE)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.TimerWithDuration("PT50M")
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.UpdateEventTrigger()
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
var newDueDate = new DateTime(ClockUtil.CurrentTime.Ticks).AddMinutes(50);
testHelper.AssertJobMigrated(testHelper.SnapshotBeforeMigration.Jobs[0], BOUNDARY_ID, newDueDate);
// and it is possible to successfully complete the migrated instance
var jobAfterMigration = testHelper.SnapshotAfterMigration.Jobs[0];
rule.ManagementService.ExecuteJob(jobAfterMigration.Id);
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.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 testProperties()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS)
.ChangeElementId(ProcessModels.ProcessKey, "new" + ProcessModels.ProcessKey)
.ChangeElementId("externalTask", "newExternalTask"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("externalTask", "newExternalTask")
.Build();
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var externalTaskBeforeMigration = rule.ExternalTaskService.CreateExternalTaskQuery()
.First();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then all properties are the same apart from the process reference
var externalTaskAfterMigration = rule.ExternalTaskService.CreateExternalTaskQuery()
.First();
Assert.AreEqual("newExternalTask", externalTaskAfterMigration.ActivityId);
Assert.AreEqual(targetProcessDefinition.Id, externalTaskAfterMigration.ProcessDefinitionId);
Assert.AreEqual("new" + ProcessModels.ProcessKey, externalTaskAfterMigration.ProcessDefinitionKey);
Assert.AreEqual(externalTaskBeforeMigration.Priority, externalTaskAfterMigration.Priority);
Assert.AreEqual(externalTaskBeforeMigration.ActivityInstanceId,
externalTaskAfterMigration.ActivityInstanceId);
Assert.AreEqual(externalTaskBeforeMigration.ErrorMessage, externalTaskAfterMigration.ErrorMessage);
Assert.AreEqual(externalTaskBeforeMigration.ExecutionId, externalTaskAfterMigration.ExecutionId);
Assert.AreEqual(externalTaskBeforeMigration.Id, externalTaskAfterMigration.Id);
Assert.AreEqual(externalTaskBeforeMigration.LockExpirationTime,
externalTaskAfterMigration.LockExpirationTime);
Assert.AreEqual(processInstance.Id, externalTaskAfterMigration.ProcessInstanceId);
Assert.AreEqual(externalTaskBeforeMigration.Retries, externalTaskAfterMigration.Retries);
Assert.AreEqual(externalTaskBeforeMigration.TenantId, externalTaskAfterMigration.TenantId);
Assert.AreEqual(externalTaskBeforeMigration.TopicName, externalTaskAfterMigration.TopicName);
Assert.AreEqual(externalTaskBeforeMigration.WorkerId, externalTaskAfterMigration.WorkerId);
}
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 testMigrateBoundaryEventToParallelSubProcess()
{
// given
var sourceProcess = ProcessModels.ParallelSubprocessProcess.Clone();
var eventTrigger = eventFactory.AddBoundaryEvent(rule.ProcessEngine, sourceProcess,
"subProcess1", BOUNDARY_ID);
ModifiableBpmnModelInstance.Wrap(sourceProcess)
//.FlowNodeBuilder(BOUNDARY_ID)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(sourceProcess)
.ChangeElementId(BOUNDARY_ID, NEW_BOUNDARY_ID);
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("subProcess1", "subProcess1")
.MapActivities(USER_TASK_1_ID, USER_TASK_1_ID)
.MapActivities("subProcess2", "subProcess2")
.MapActivities(USER_TASK_2_ID, USER_TASK_2_ID)
.MapActivities(BOUNDARY_ID, NEW_BOUNDARY_ID)
.UpdateEventTrigger()
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
eventTrigger.AssertEventTriggerMigrated(testHelper, NEW_BOUNDARY_ID);
// and it is possible to successfully complete the migrated instance
testHelper.CompleteTask(USER_TASK_1_ID);
testHelper.CompleteTask(USER_TASK_2_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testUpdateConditionalEventExpression()
{
// given
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Condition(FALSE_CONDITION)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Condition(VAR_CONDITION)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.UpdateEventTrigger()
.Build();
// when process is migrated without update event trigger
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then condition is migrated and has new condition expr
testHelper.AssertEventSubscriptionMigrated(BOUNDARY_ID, BOUNDARY_ID, null);
// and it is possible to successfully complete the migrated instance
testHelper.AnyVariable = testHelper.SnapshotAfterMigration.ProcessInstanceId;
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testUpdateEventSignal()
{
// given
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Signal(SIGNAL_NAME)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Signal("new" + SIGNAL_NAME)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.UpdateEventTrigger()
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionMigrated(BOUNDARY_ID, SIGNAL_NAME, BOUNDARY_ID, "new" + SIGNAL_NAME);
// and it is possible to successfully complete the migrated instance
rule.RuntimeService.SignalEventReceived("new" + SIGNAL_NAME);
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testAddGatewayIncomingSequenceFlow()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(GatewayModels.PARALLEL_GW);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(GatewayModels.PARALLEL_GW)
//.FlowNodeBuilder("fork")
//.UserTask("parallel3")
//.ConnectTo("join")
//.Done()
);
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
testHelper.CompleteTask("parallel2");
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("parallel1", "parallel1")
.MapActivities("join", "join")
.Build();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then
Assert.AreEqual(1, rule.TaskService.CreateTaskQuery()
.Count());
Assert.AreEqual(0, rule.TaskService.CreateTaskQuery(c => c.TaskDefinitionKeyWithoutCascade == "afterJoin")
.Count());
rule.RuntimeService.CreateProcessInstanceModification(processInstance.Id)
.StartBeforeActivity("join")
.Execute();
Assert.AreEqual(0, rule.TaskService.CreateTaskQuery(c => c.TaskDefinitionKeyWithoutCascade == "afterJoin")
.Count());
testHelper.CompleteTask("parallel1");
testHelper.CompleteTask("afterJoin");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testUpdateEventTimer()
{
// given
ClockTestUtil.SetClockToDateWithoutMilliseconds();
var sourceProcess = EventSubProcessModels.TIMER_EVENT_SUBPROCESS_PROCESS;
var targetProcess = ModifiableBpmnModelInstance.Modify(EventSubProcessModels.TIMER_EVENT_SUBPROCESS_PROCESS)
.RemoveChildren(EVENT_SUB_PROCESS_START_ID)
.StartEventBuilder(EVENT_SUB_PROCESS_START_ID)
.TimerWithDuration("PT50M")
.Done();
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var 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
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
var newDueDate = new DateTime(ClockUtil.CurrentTime.Ticks).AddMinutes(50);
testHelper.AssertJobMigrated(testHelper.SnapshotBeforeMigration.Jobs[0], EVENT_SUB_PROCESS_START_ID,
newDueDate);
// and it is possible to successfully complete the migrated instance
var jobAfterMigration = testHelper.SnapshotAfterMigration.Jobs[0];
rule.ManagementService.ExecuteJob(jobAfterMigration.Id);
testHelper.CompleteTask(EVENT_SUB_PROCESS_TASK_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testMigrateBoundaryEventOnConcurrentScopeUserTaskAndTriggerEvent()
{
// given
var sourceProcess = ProcessModels.ScopeTaskProcess.Clone();
var eventTrigger = eventFactory.AddBoundaryEvent(rule.ProcessEngine, sourceProcess,
USER_TASK_1_ID, BOUNDARY_ID);
ModifiableBpmnModelInstance.Wrap(sourceProcess)
//.FlowNodeBuilder(BOUNDARY_ID)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(sourceProcess)
.ChangeElementId("boundary", "newBoundary");
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_1_ID, USER_TASK_1_ID)
.MapActivities(USER_TASK_2_ID, USER_TASK_2_ID)
.MapActivities(BOUNDARY_ID, NEW_BOUNDARY_ID)
.UpdateEventTrigger()
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then it is possible to trigger the event and successfully complete the migrated instance
eventTrigger.InContextOf(NEW_BOUNDARY_ID)
.Trigger(processInstance.Id);
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.CompleteTask(USER_TASK_2_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testUpdateEventMessageNameWithExpression()
{
// given
var messageNameWithExpression = "new" + MESSAGE_NAME + "-${var}";
var sourceProcess = ProcessModels.OneTaskProcess;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Message(messageNameWithExpression)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.Build();
var variables = new Dictionary <string, object>();
variables["var"] = "foo";
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan, variables);
// the message event subscription's event name has changed
var resolvedMessageName = "new" + MESSAGE_NAME + "-foo";
testHelper.AssertEventSubscriptionCreated(BOUNDARY_ID, resolvedMessageName);
// and it is possible to successfully complete the migrated instance
rule.RuntimeService.CorrelateMessage(resolvedMessageName);
testHelper.CompleteTask(AFTER_BOUNDARY_TASK);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testCase1CannotTriggerCompensationInNewScope()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(CompensationModels.ONE_COMPENSATION_TASK_MODEL);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(CompensationModels.COMPENSATION_TWO_TASKS_SUBPROCESS_MODEL)
.EndEventBuilder("subProcessEnd")
//.CompensateEventDefinition()
//.WaitForCompletion(true)
//.CompensateEventDefinitionDone()
.Done());
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask2", "userTask2")
.MapActivities("compensationBoundary", "compensationBoundary")
.Build();
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
testHelper.CompleteTask("userTask1");
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then compensation is only caught outside of the subProcess
testHelper.CompleteTask("userTask2");
var activityInstance = rule.RuntimeService.GetActivityInstance(processInstance.Id);
ActivityInstanceAssert.That(activityInstance)
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(targetProcessDefinition.Id)
.Activity("compensationEvent")
.BeginScope("subProcess")
.Activity("compensationHandler")
.Done()); // note: this is not subProcess and subProcessEnd
}
public virtual void testNotMigrateActivitiesOfDifferentType()
{
var sourceDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var targetDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
.SwapElementIds("userTask", "subProcess"));
try
{
runtimeService.CreateMigrationPlan(sourceDefinition.Id, targetDefinition.Id)
.MapActivities("userTask", "userTask")
.Build();
Assert.Fail("Should not succeed");
}
catch (MigrationPlanValidationException e)
{
MigrationPlanValidationReportAssert.That(e.ValidationReport)
.HasInstructionFailures("userTask",
"Activities have incompatible types (UserTaskActivityBehavior is not " +
"compatible with SubProcessActivityBehavior)");
}
}
public virtual void testIncidentWithoutMapExternalTask()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS)
.ChangeElementId("externalTask", "newExternalTask"));
//external task is not mapped to new external task
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapEqualActivities()
.Build();
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var externalTask = rule.ExternalTaskService.CreateExternalTaskQuery()
.First();
rule.ExternalTaskService.SetRetries(externalTask.Id, 0);
var incidentBeforeMigration = rule.RuntimeService.CreateIncidentQuery()
.First();
Assert.NotNull(incidentBeforeMigration);
// when migration is executed
try
{
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
Assert.Fail("Exception expected!");
}
catch (System.Exception ex)
{
Assert.True(ex is MigratingProcessInstanceValidationException);
}
}
public virtual void testCannotAddScopeOnTopOfEventSubProcess()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(CompensationModels.COMPENSATION_EVENT_SUBPROCESS_MODEL);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(CompensationModels.DOUBLE_SUBPROCESS_MODEL)
.AddSubProcessTo("innerSubProcess")
//.Id("eventSubProcess")
.TriggerByEvent()
//.EmbeddedSubProcess()
//.StartEvent("eventSubProcessStart")
//.CompensateEventDefinition()
//.CompensateEventDefinitionDone()
.EndEvent()
.Done());
try
{
// when
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("subProcess", "outerSubProcess")
.MapActivities("eventSubProcessStart", "eventSubProcessStart")
.MapActivities("compensationBoundary", "compensationBoundary")
.MapActivities("userTask2", "userTask2")
.Build();
Assert.Fail("exception expected");
}
catch (MigrationPlanValidationException e)
{
// then
MigrationPlanValidationReportAssert.That(e.ValidationReport)
.HasInstructionFailures("eventSubProcessStart",
"The source activity's event scope (subProcess) must be mapped to the target activity's event scope (innerSubProcess)");
}
}
public virtual void testCannotRemoveGatewayIncomingSequenceFlow()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(GatewayModels.PARALLEL_GW);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(GatewayModels.PARALLEL_GW)
.RemoveFlowNode("parallel2"));
try
{
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("join", "join")
.Build();
Assert.Fail("exception expected");
}
catch (MigrationPlanValidationException e)
{
// then
MigrationPlanValidationReportAssert.That(e.ValidationReport)
.HasInstructionFailures("join",
"The target gateway must have at least the same number of incoming sequence flows that the source gateway has");
}
}
public virtual void testEndListenerInvocationForRemovedScope()
{
// given
DelegateEvent.ClearEvents();
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.GetName method:
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.CamundaExecutionListenerClass(ExecutionListenerFields.EventNameEnd,
// typeof(DelegateExecutionListener).FullName)
//.Done()
);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
var recordedEvents = DelegateEvent.Events;
Assert.AreEqual(1, recordedEvents.Count);
var @event = recordedEvents[0];
Assert.AreEqual(sourceProcessDefinition.Id, @event.ProcessDefinitionId);
Assert.AreEqual("subProcess", @event.CurrentActivityId);
Assert.AreEqual(testHelper.GetSingleActivityInstanceBeforeMigration("subProcess")
.Id, @event.ActivityInstanceId);
DelegateEvent.ClearEvents();
}
public virtual void testMigrateGatewayAddTimerEvent()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(EventBasedGatewayModels.TIMER_EVENT_BASED_GW_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(EventBasedGatewayModels.TIMER_EVENT_BASED_GW_PROCESS)
//.FlowNodeBuilder("eventBasedGateway")
//.IntermediateCatchEvent("newTimerCatch")
//.TimerWithDuration("PT50M")
//.UserTask("afterNewTimerCatch")
//.EndEvent()
//.Done()
);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("eventBasedGateway", "eventBasedGateway")
.MapActivities("timerCatch", "timerCatch")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertIntermediateTimerJobCreated("newTimerCatch");
testHelper.AssertIntermediateTimerJobMigrated("timerCatch", "timerCatch");
var newTimerJob = rule.ManagementService.CreateJobQuery(c => c.ActivityId == "newTimerCatch")
.First();
rule.ManagementService.ExecuteJob(newTimerJob.Id);
testHelper.CompleteTask("afterNewTimerCatch");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testUpdateEventSignalWithExpression()
{
// given
var newSignalNameWithExpression = "new" + EventSubProcessModels.MESSAGE_NAME + "-${var}";
var sourceProcess = EventSubProcessModels.SIGNAL_EVENT_SUBPROCESS_PROCESS;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(
EventSubProcessModels.SIGNAL_EVENT_SUBPROCESS_PROCESS)
.RenameSignal(EventSubProcessModels.SIGNAL_NAME, newSignalNameWithExpression);
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var 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();
var variables = new Dictionary <string, object>();
variables["var"] = "foo";
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan, variables);
// then
var resolvedsignalName = "new" + EventSubProcessModels.MESSAGE_NAME + "-foo";
testHelper.AssertEventSubscriptionMigrated(EVENT_SUB_PROCESS_START_ID, EventSubProcessModels.SIGNAL_NAME,
EVENT_SUB_PROCESS_START_ID, resolvedsignalName);
// and it is possible to successfully complete the migrated instance
rule.RuntimeService.SignalEventReceived(resolvedsignalName);
testHelper.CompleteTask(EVENT_SUB_PROCESS_TASK_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testMigrateBoundaryEventAndEventSubProcess()
{
var testProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
.AddSubProcessTo("subProcess")
.TriggerByEvent()
////.EmbeddedSubProcess()
//.StartEvent("eventStart")
////.Message(MESSAGE_NAME)
.EndEvent()
.SubProcessDone()
//.MoveToActivity(USER_TASK_ID)
.BoundaryEvent(BOUNDARY_ID)
.Signal(SIGNAL_NAME)
.Done();
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionRemoved("eventStart", MESSAGE_NAME);
testHelper.AssertEventSubscriptionMigrated(BOUNDARY_ID, BOUNDARY_ID, SIGNAL_NAME);
testHelper.AssertEventSubscriptionCreated("eventStart", MESSAGE_NAME);
// and it is possible to successfully complete the migrated instance
testHelper.CompleteTask(USER_TASK_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testRemoveMultipleBoundaryEvents()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.BoundaryEvent("timerBoundary")
//.TimerWithDate(TIMER_DATE)
//.MoveToActivity("userTask")
//.BoundaryEvent("messageBoundary")
////.Message(MESSAGE_NAME)
//.MoveToActivity("userTask")
//.BoundaryEvent("signalBoundary")
//.Signal(SIGNAL_NAME)
//.Done()
);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.SubprocessProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("subProcess", "subProcess")
.MapActivities("userTask", "userTask")
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionRemoved("messageBoundary", MESSAGE_NAME);
testHelper.AssertEventSubscriptionRemoved("signalBoundary", SIGNAL_NAME);
testHelper.AssertBoundaryTimerJobRemoved("timerBoundary");
// and it is possible to successfully complete the migrated instance
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testMigrateEventSubscriptionUpdateMessageNameWithExpression()
{
// given
var newMessageName = "new" + MessageReceiveModels.MESSAGE_NAME + "-${var}";
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(MessageReceiveModels.ONE_MESSAGE_CATCH_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
MessageReceiveModels.ONE_MESSAGE_CATCH_PROCESS)
.RenameMessage(MessageReceiveModels.MESSAGE_NAME, newMessageName));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("messageCatch", "messageCatch")
.UpdateEventTrigger()
.Build();
var variables = new Dictionary <string, object>();
variables["var"] = "foo";
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan, variables);
// then the message event subscription's event name has changed
var resolvedMessageName = "new" + MessageReceiveModels.MESSAGE_NAME + "-foo";
testHelper.AssertEventSubscriptionMigrated("messageCatch", MessageReceiveModels.MESSAGE_NAME, "messageCatch",
resolvedMessageName);
// and it is possible to trigger the event
rule.RuntimeService.CorrelateMessage(resolvedMessageName);
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testNoOutputMappingExecuted()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL)
//.ActivityBuilder("subProcess")
//.CamundaOutputParameter("foo", "${bar}")
//.Done()
);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(CompensationModels.ONE_COMPENSATION_TASK_MODEL);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask2", "userTask2")
.MapActivities("compensationBoundary", "compensationBoundary")
.Build();
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
rule.RuntimeService.SetVariable(processInstance.Id, "bar", "value1");
testHelper.CompleteTask("userTask1"); // => sets "foo" to "value1"
rule.RuntimeService.SetVariable(processInstance.Id, "bar", "value2");
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then "foo" has not been set to "value2"
Assert.AreEqual(2, testHelper.SnapshotAfterMigration.GetVariables()
.Count); // "foo" and "bar"
var variableInstance = testHelper.SnapshotAfterMigration.GetSingleVariable("foo");
Assert.AreEqual("value1", variableInstance.Value);
}
public virtual void testMigrateNonInterruptingEventSubprocessMessageTrigger()
{
var nonInterruptingModel =
ModifiableBpmnModelInstance.Modify(EventSubProcessModels.MESSAGE_EVENT_SUBPROCESS_PROCESS)
.StartEventBuilder(EVENT_SUB_PROCESS_START_ID)
.Interrupting(false)
.Done();
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(nonInterruptingModel);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(nonInterruptingModel);
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
var 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)
.Build();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then
testHelper.AssertEventSubscriptionMigrated(EVENT_SUB_PROCESS_START_ID, EVENT_SUB_PROCESS_START_ID,
EventSubProcessModels.MESSAGE_NAME);
// and it is possible to trigger the event subprocess
rule.RuntimeService.CorrelateMessage(EventSubProcessModels.MESSAGE_NAME);
Assert.AreEqual(2, rule.TaskService.CreateTaskQuery()
.Count());
// and complete the process instance
testHelper.CompleteTask(EVENT_SUB_PROCESS_TASK_ID);
testHelper.CompleteTask(USER_TASK_ID);
testHelper.AssertProcessEnded(processInstance.Id);
}
