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);
}
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);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSignalConditionOnUnlock()
public virtual void shouldSignalConditionOnUnlock()
{
// given
rule.RuntimeService.startProcessInstanceByKey("theProcess");
reset(condition); // clear signal for create
LockedExternalTask lockedTask = rule.ExternalTaskService.fetchAndLock(1, "theWorker").topic("theTopic", 10000).execute()[0];
// when
rule.ExternalTaskService.unlock(lockedTask.Id);
// then
verify(condition, times(1)).signal();
}
public override void testExternalTaskApi(LockedExternalTask task)
{
engineRule.ExternalTaskService.complete(task.Id, "workerId");
}
public override void testExternalTaskApi(LockedExternalTask task)
{
engineRule.ExternalTaskService.extendLock(task.Id, "workerId", 2000L);
}
public override void testExternalTaskApi(LockedExternalTask task)
{
engineRule.ExternalTaskService.handleFailure(task.Id, "workerId", "error", 5, 5000L);
}
public override void testExternalTaskApi(LockedExternalTask task)
{
engineRule.ExternalTaskService.handleBpmnError(task.Id, "workerId", "errorCode");
}
