public virtual void testMapEqualActivitiesWithParallelMultiInstance()
{
// given
IBpmnModelInstance testProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.GetBuilderForElementById("userTask", typeof(UserTaskBuilder))
//.MultiInstance()
//.Parallel()
//.Cardinality("3")
//.MultiInstanceDone()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
// when
try
{
runtimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.Build();
Assert.Fail("Should not succeed");
}
catch (MigrationPlanValidationException e)
{
MigrationPlanValidationReportAssert.That(e.ValidationReport)
.HasInstructionFailures("userTask",
"Target activity 'userTask' is a descendant of multi-instance body 'userTask#multiInstanceBody' " +
"that is not mapped from the source process definition.");
}
}
public virtual void testSkipListenerInvocationForRemovedScope()
{
// 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
var processInstance = rule.RuntimeService.StartProcessInstanceById(migrationPlan.SourceProcessDefinitionId);
rule.RuntimeService.NewMigration(migrationPlan)
.ProcessInstanceIds(processInstance.Id)
.SkipCustomListeners()
.Execute();
// then
var recordedEvents = DelegateEvent.Events;
Assert.AreEqual(0, recordedEvents.Count);
DelegateEvent.ClearEvents();
}
public virtual void testSkipIoMappingInvocationForRemovedScope()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.CamundaOutputParameter("foo", "bar")
//.Done()
);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.Build();
// when
var processInstance = rule.RuntimeService.StartProcessInstanceById(migrationPlan.SourceProcessDefinitionId);
rule.RuntimeService.NewMigration(migrationPlan)
.ProcessInstanceIds(processInstance.Id)
.SkipIoMappings()
.Execute();
// then
Assert.AreEqual(0, rule.RuntimeService.CreateVariableInstanceQuery()
.Count());
}
public virtual void testAddScopeDoesNotBecomeAsync()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.CamundaAsyncBefore()
//.Done()
);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then the async flag for the subprocess was not relevant for instantiation
testHelper.AssertActivityTreeAfterMigration()
.HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(targetProcessDefinition.Id)
.BeginScope("subProcess")
.Activity("userTask", testHelper.GetSingleActivityInstanceBeforeMigration("userTask")
.Id)
.Done());
Assert.AreEqual(0, testHelper.SnapshotAfterMigration.Jobs.Count);
}
public virtual void testListenerInvocationForNewlyCreatedScope()
{
// given
DelegateEvent.ClearEvents();
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.CamundaExecutionListenerClass(ExecutionListenerFields.EventNameStart,
// typeof(DelegateExecutionListener).FullName)
//.Done()
);
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(targetProcessDefinition.Id, @event.ProcessDefinitionId);
Assert.AreEqual("subProcess", @event.CurrentActivityId);
DelegateEvent.ClearEvents();
}
public virtual void testMigrateGatewayWithTimerEventChangeId()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(EventBasedGatewayModels.TIMER_EVENT_BASED_GW_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
EventBasedGatewayModels.TIMER_EVENT_BASED_GW_PROCESS)
.ChangeElementId("timerCatch", "newTimerCatch"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("eventBasedGateway", "eventBasedGateway")
.MapActivities("timerCatch", "newTimerCatch")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertIntermediateTimerJobMigrated("timerCatch", "newTimerCatch");
var timerJob = testHelper.SnapshotAfterMigration.Jobs[0];
rule.ManagementService.ExecuteJob(timerJob.Id);
testHelper.CompleteTask("afterTimerCatch");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testMigrateIncidentForJob()
{
// given
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.GetName method:
var sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
.UserTaskBuilder(USER_TASK_ID)
.BoundaryEvent(BOUNDARY_ID)
.TimerWithDate(TIMER_DATE)
.ServiceTask("failingTask")
.CamundaClass(typeof(FailingDelegate).FullName)
.EndEvent()
.Done();
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(sourceProcess)
.ChangeElementId(USER_TASK_ID, "newUserTask")
.ChangeElementId(BOUNDARY_ID, "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();
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, "newUserTask")
.MapActivities(BOUNDARY_ID, "newBoundary")
.Build();
// when
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// then the job and incident still exists
var jobAfterMigration = rule.ManagementService.CreateJobQuery(c => c.Id == jobBeforeMigration.Id)
.First();
Assert.NotNull(jobAfterMigration);
var incidentAfterMigration = rule.RuntimeService.CreateIncidentQuery()
.First();
Assert.NotNull(incidentAfterMigration);
// and it is still the same incident
Assert.AreEqual(incidentBeforeMigration.Id, incidentAfterMigration.Id);
Assert.AreEqual(jobAfterMigration.Id, incidentAfterMigration.Configuration);
// and the activity, process definition and job definition references were updated
Assert.AreEqual("newBoundary", incidentAfterMigration.ActivityId);
Assert.AreEqual(targetProcessDefinition.Id, incidentAfterMigration.ProcessDefinitionId);
Assert.AreEqual(jobAfterMigration.JobDefinitionId, incidentAfterMigration.JobDefinitionId);
}
public virtual void testAccessModelInTaskListenerAfterMigration()
{
IBpmnModelInstance targetModel = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
.ChangeElementId("userTask", "newUserTask");
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.GetName method:
addTaskListener(targetModel, "newUserTask", TaskListenerFields.EventnameAssignment,
typeof(AccessModelInstanceTaskListener).FullName);
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetModel);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "newUserTask")
.Build();
var processInstance = rule.RuntimeService.StartProcessInstanceById(sourceProcessDefinition.Id);
testHelper.MigrateProcessInstance(migrationPlan, processInstance);
// when
var task = rule.TaskService.CreateTaskQuery()
.First();
rule.TaskService.SetAssignee(task.Id, "foo");
// then the task listener was able to access the bpmn model instance and set a variable
var variableValue =
(string)
rule.RuntimeService.GetVariable(processInstance.Id, AccessModelInstanceTaskListener.VARIABLE_NAME);
Assert.AreEqual("newUserTask", variableValue);
}
public virtual void testMigrateSequentialMultiInstanceEventSubscription()
{
IBpmnModelInstance parallelMiReceiveTaskProcess =
ModifiableBpmnModelInstance.Modify(MessageReceiveModels.ONE_RECEIVE_TASK_PROCESS)
//.ActivityBuilder("receiveTask")
//.MultiInstance()
//.Sequential()
//.Cardinality("3")
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(parallelMiReceiveTaskProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(parallelMiReceiveTaskProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("receiveTask#multiInstanceBody", "receiveTask#multiInstanceBody")
.MapActivities("receiveTask", "receiveTask")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
testHelper.AssertEventSubscriptionsMigrated("receiveTask", "receiveTask", MessageReceiveModels.MESSAGE_NAME);
// and it is possible to trigger the receive tasks
for (var i = 0; i < 3; i++)
{
rule.RuntimeService.CorrelateMessage(MessageReceiveModels.MESSAGE_NAME);
}
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testMapUserTaskInEventSubProcess()
{
var testProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
.AddSubProcessTo("subProcess")
.TriggerByEvent()
////.EmbeddedSubProcess()
//.StartEvent()
////.Message(MESSAGE_NAME)
.UserTask("innerTask")
.EndEvent()
.SubProcessDone()
.Done();
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var migrationPlan =
runtimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.MapActivities("innerTask", "innerTask")
.Build();
MigrationPlanAssert.That(migrationPlan)
.HasSourceProcessDefinition(sourceProcessDefinition)
.HasTargetProcessDefinition(targetProcessDefinition)
.HasInstructions(MigrationPlanAssert.Migrate("userTask")
.To("userTask"), MigrationPlanAssert.Migrate("innerTask")
.To("innerTask"));
}
public virtual void testCannotMigrateWhenNotAllTransitionInstancesAreMapped()
{
// given
IBpmnModelInstance model = ModifiableBpmnModelInstance.Modify(ProcessModels.ParallelGatewayProcess)
//.ActivityBuilder("userTask1")
//.CamundaAsyncBefore()
//.MoveToActivity("userTask2")
//.CamundaAsyncBefore()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(model);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(model);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask1", "userTask1")
.Build();
// when
try
{
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
Assert.Fail("should not succeed because the userTask2 instance is not mapped");
}
catch (MigratingProcessInstanceValidationException e)
{
MigratingProcessInstanceValidationReportAssert.That(e.ValidationReport)
.HasTransitionInstanceFailures("userTask2",
"There is no migration instruction for this instance's activity");
}
}
public virtual void testMapAllBoundaryEvents()
{
IBpmnModelInstance testProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.BoundaryEvent("error")
//.Error(ERROR_CODE)
//.MoveToActivity("subProcess")
//.BoundaryEvent("escalation")
//.Escalation(ESCALATION_CODE)
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(testProcess);
var migrationPlan =
runtimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("subProcess", "subProcess")
.MapActivities("error", "error")
.MapActivities("escalation", "escalation")
.MapActivities("userTask", "userTask")
.Build();
MigrationPlanAssert.That(migrationPlan)
.HasSourceProcessDefinition(sourceProcessDefinition)
.HasTargetProcessDefinition(targetProcessDefinition)
.HasInstructions(MigrationPlanAssert.Migrate("subProcess")
.To("subProcess"), MigrationPlanAssert.Migrate("error")
.To("error"), MigrationPlanAssert.Migrate("escalation")
.To("escalation"), MigrationPlanAssert.Migrate("userTask")
.To("userTask"));
}
public virtual void testMapBoundaryToChildActivity()
{
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.BoundaryEvent("boundary")
////.Message(MESSAGE_NAME)
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
////.Message(MESSAGE_NAME)
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
try
{
runtimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("subProcess", "subProcess")
.MapActivities("userTask", "userTask")
.MapActivities("boundary", "boundary")
.Build();
Assert.Fail("Should not succeed");
}
catch (MigrationPlanValidationException e)
{
MigrationPlanValidationReportAssert.That(e.ValidationReport)
.HasInstructionFailures("boundary",
"The source activity's event scope (subProcess) must be mapped to the target activity's event scope (userTask)");
}
}
public virtual void testMapBoundaryToLowerScope()
{
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
////.Message(MESSAGE_NAME)
//.Done()
;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
////.Message(MESSAGE_NAME)
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(targetProcess);
var migrationPlan =
runtimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.MapActivities("boundary", "boundary")
.Build();
MigrationPlanAssert.That(migrationPlan)
.HasSourceProcessDefinition(sourceProcessDefinition)
.HasTargetProcessDefinition(targetProcessDefinition)
.HasInstructions(MigrationPlanAssert.Migrate("userTask")
.To("userTask"), MigrationPlanAssert.Migrate("boundary")
.To("boundary"));
}
public virtual void testMigrateGatewayRemoveTimerEvent()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(EventBasedGatewayModels.TIMER_EVENT_BASED_GW_PROCESS)
//.FlowNodeBuilder("eventBasedGateway")
//.IntermediateCatchEvent("oldTimerCatch")
//.TimerWithDuration("PT50M")
//.EndEvent()
//.Done()
);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(EventBasedGatewayModels.TIMER_EVENT_BASED_GW_PROCESS);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("eventBasedGateway", "eventBasedGateway")
.MapActivities("timerCatch", "timerCatch")
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertIntermediateTimerJobRemoved("oldTimerCatch");
testHelper.AssertIntermediateTimerJobMigrated("timerCatch", "timerCatch");
}
public virtual void testMigrateEventSubscriptionChangeActivityId()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(MessageReceiveModels.ONE_RECEIVE_TASK_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
MessageReceiveModels.ONE_RECEIVE_TASK_PROCESS)
.ChangeElementId("receiveTask", "newReceiveTask"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("receiveTask", "newReceiveTask")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
testHelper.AssertEventSubscriptionMigrated("receiveTask", "newReceiveTask",
MessageReceiveModels.MESSAGE_NAME);
// and it is possible to trigger the receive task
rule.RuntimeService.CorrelateMessage(MessageReceiveModels.MESSAGE_NAME);
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testMigrateGatewayRemoveSignalEvent()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(EventBasedGatewayModels.SIGNAL_EVENT_BASED_GW_PROCESS)
//.FlowNodeBuilder("eventBasedGateway")
//.IntermediateCatchEvent("oldSignalCatch")
//.Signal("old" + EventBasedGatewayModels.SIGNAL_NAME)
//.EndEvent()
//.Done()
);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(EventBasedGatewayModels.SIGNAL_EVENT_BASED_GW_PROCESS);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("eventBasedGateway", "eventBasedGateway")
.MapActivities("signalCatch", "signalCatch")
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionRemoved("oldSignalCatch", "old" + EventBasedGatewayModels.SIGNAL_NAME);
testHelper.AssertEventSubscriptionMigrated("signalCatch", "signalCatch", EventBasedGatewayModels.SIGNAL_NAME);
}
public virtual void testMigrateEventSubscriptionChangeActivityId()
{
// given
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(SignalCatchModels.ONE_SIGNAL_CATCH_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
SignalCatchModels.ONE_SIGNAL_CATCH_PROCESS)
.ChangeElementId("signalCatch", "newSignalCatch"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("signalCatch", "newSignalCatch")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionMigrated("signalCatch", "newSignalCatch", SignalCatchModels.SIGNAL_NAME);
// and it is possible to trigger the event
rule.RuntimeService.SignalEventReceived(SignalCatchModels.SIGNAL_NAME);
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testMigrateGatewayWithSignalEventChangeId()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(EventBasedGatewayModels.SIGNAL_EVENT_BASED_GW_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(
EventBasedGatewayModels.SIGNAL_EVENT_BASED_GW_PROCESS)
.ChangeElementId("signalCatch", "newSignalCatch"));
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("eventBasedGateway", "eventBasedGateway")
.MapActivities("signalCatch", "newSignalCatch")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionMigrated("signalCatch", "newSignalCatch",
EventBasedGatewayModels.SIGNAL_NAME);
rule.RuntimeService.SignalEventReceived(EventBasedGatewayModels.SIGNAL_NAME);
testHelper.CompleteTask("afterSignalCatch");
testHelper.AssertProcessEnded(processInstance.Id);
}
public virtual void testMigrateGatewayAddMessageEvent()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(EventBasedGatewayModels.MESSAGE_EVENT_BASED_GW_PROCESS);
var targetProcessDefinition =
testHelper.DeployAndGetDefinition(
ModifiableBpmnModelInstance.Modify(EventBasedGatewayModels.MESSAGE_EVENT_BASED_GW_PROCESS)
//.FlowNodeBuilder("eventBasedGateway")
//.IntermediateCatchEvent("newMessageCatch")
//.Message("new" + EventBasedGatewayModels.MESSAGE_NAME)
//.UserTask("afterNewMessageCatch")
//.EndEvent()
//.Done()
);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("eventBasedGateway", "eventBasedGateway")
.MapActivities("messageCatch", "messageCatch")
.Build();
// when
var processInstance = testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionCreated("newMessageCatch", "new" + EventBasedGatewayModels.MESSAGE_NAME);
testHelper.AssertEventSubscriptionMigrated("messageCatch", "messageCatch",
EventBasedGatewayModels.MESSAGE_NAME);
rule.RuntimeService.CorrelateMessage("new" + EventBasedGatewayModels.MESSAGE_NAME);
testHelper.CompleteTask("afterNewMessageCatch");
testHelper.AssertProcessEnded(processInstance.Id);
}
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 testRemoveTimerBoundaryEventFromUserTaskInSubProcess()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
//.TimerWithDate(TIMER_DATE)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.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.AssertBoundaryTimerJobRemoved("boundary");
// and it is possible to successfully complete the migrated instance
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testRemoveEscalationBoundaryEventFromSubProcess()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.SubprocessProcess)
//.ActivityBuilder("subProcess")
//.BoundaryEvent()
//.Escalation(ESCALATION_CODE)
//.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 it is possible to successfully complete the migrated instance
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testRemoveMessageBoundaryEventFromScopeUserTask()
{
// given
var sourceProcessDefinition =
testHelper.DeployAndGetDefinition(ModifiableBpmnModelInstance.Modify(ProcessModels.ScopeTaskProcess)
//.ActivityBuilder("userTask")
//.BoundaryEvent("boundary")
////.Message(MESSAGE_NAME)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ScopeTaskProcess);
var migrationPlan =
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities("userTask", "userTask")
.Build();
// when
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.AssertEventSubscriptionRemoved("boundary", MESSAGE_NAME);
// and it is possible to successfully complete the migrated instance
testHelper.CompleteTask("userTask");
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testUpdateConditionalEventExpression()
{
// given
var sourceProcess = EventSubProcessModels.FALSE_CONDITIONAL_EVENT_SUBPROCESS_PROCESS;
IBpmnModelInstance targetProcess =
ModifiableBpmnModelInstance.Modify(EventSubProcessModels.CONDITIONAL_EVENT_SUBPROCESS_PROCESS);
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 process is migrated without update event trigger
testHelper.CreateProcessInstanceAndMigrate(migrationPlan);
// then condition is migrated and has new condition expr
testHelper.AssertEventSubscriptionMigrated(EVENT_SUB_PROCESS_START_ID, EVENT_SUB_PROCESS_START_ID, null);
// and it is possible to successfully complete the migrated instance
testHelper.AnyVariable = testHelper.SnapshotAfterMigration.ProcessInstanceId;
testHelper.CompleteTask(EVENT_SUB_PROCESS_TASK_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
public virtual void testUpdateEventSignal()
{
// given
var sourceProcess = EventSubProcessModels.SIGNAL_EVENT_SUBPROCESS_PROCESS;
IBpmnModelInstance targetProcess = ModifiableBpmnModelInstance.Modify(
EventSubProcessModels.SIGNAL_EVENT_SUBPROCESS_PROCESS)
.RenameSignal(EventSubProcessModels.SIGNAL_NAME, "new" + EventSubProcessModels.SIGNAL_NAME);
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
testHelper.AssertEventSubscriptionMigrated(EVENT_SUB_PROCESS_START_ID, EventSubProcessModels.SIGNAL_NAME,
EVENT_SUB_PROCESS_START_ID, "new" + EventSubProcessModels.SIGNAL_NAME);
// and it is possible to successfully complete the migrated instance
rule.RuntimeService.SignalEventReceived("new" + EventSubProcessModels.SIGNAL_NAME);
testHelper.CompleteTask(EVENT_SUB_PROCESS_TASK_ID);
testHelper.AssertProcessEnded(testHelper.SnapshotBeforeMigration.ProcessInstanceId);
}
//[ExpectedException(typeof(MigrationPlanValidationException))]
public virtual void testMigrateConditionalBoundaryEventKeepTrigger()
{
// given
IBpmnModelInstance sourceProcess = ModifiableBpmnModelInstance.Modify(ProcessModels.OneTaskProcess)
//.ActivityBuilder(USER_TASK_ID)
//.BoundaryEvent(BOUNDARY_ID)
//.Condition(FALSE_CONDITION)
//.UserTask(AFTER_BOUNDARY_TASK)
//.EndEvent()
//.Done()
;
var sourceProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
var targetProcessDefinition = testHelper.DeployAndGetDefinition(sourceProcess);
// expected migration validation exception
//exceptionRule.Expect(typeof(MigrationPlanValidationException));
//exceptionRule.ExpectMessage(MIGRATION_CONDITIONAL_VALIDATION_ERROR_MSG);
// when conditional boundary event is migrated without update event trigger
rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id)
.MapActivities(USER_TASK_ID, USER_TASK_ID)
.MapActivities(BOUNDARY_ID, BOUNDARY_ID)
.Build();
}
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 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);
}
