public virtual void testHistory()
{
// given
Task compensationHandler = rule.taskQuery().singleResult();
// when
rule.TaskService.complete(compensationHandler.Id);
// then history is written for the remaining activity instances
HistoricProcessInstance historicProcessInstance = rule.historicProcessInstance();
Assert.assertNotNull(historicProcessInstance);
Assert.assertNotNull(historicProcessInstance.EndTime);
HistoricActivityInstance subProcessInstance = rule.HistoryService.createHistoricActivityInstanceQuery().processInstanceId(historicProcessInstance.Id).activityId("subProcess").singleResult();
Assert.assertNotNull(subProcessInstance);
Assert.assertNotNull(subProcessInstance.EndTime);
Assert.assertEquals(historicProcessInstance.Id, subProcessInstance.ParentActivityInstanceId);
HistoricActivityInstance compensationThrowInstance = rule.HistoryService.createHistoricActivityInstanceQuery().processInstanceId(historicProcessInstance.Id).activityId("throwCompensate").singleResult();
Assert.assertNotNull(compensationThrowInstance);
Assert.assertNotNull(compensationThrowInstance.EndTime);
Assert.assertEquals(subProcessInstance.Id, compensationThrowInstance.ParentActivityInstanceId);
HistoricActivityInstance compensationHandlerInstance = rule.HistoryService.createHistoricActivityInstanceQuery().processInstanceId(historicProcessInstance.Id).activityId("undoTask").singleResult();
Assert.assertNotNull(compensationHandlerInstance);
Assert.assertNotNull(compensationHandlerInstance.EndTime);
Assert.assertEquals(subProcessInstance.Id, compensationHandlerInstance.ParentActivityInstanceId);
}
public virtual void checkDeleteHistoricProcessInstance(HistoricProcessInstance instance)
{
if (instance != null && !TenantManager.isAuthenticatedTenant(instance.TenantId))
{
throw LOG.exceptionCommandWithUnauthorizedTenant("delete the historic process instance '" + instance.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);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testPAGroovyProcessEnginePlugin()
public virtual void testPAGroovyProcessEnginePlugin()
{
ProcessEngine groovyEngine = processEngineService.getProcessEngine("groovy");
Assert.assertNotNull(groovyEngine);
ProcessInstance pi = groovyEngine.RuntimeService.startProcessInstanceByKey("groovy");
HistoricProcessInstance hpi = groovyEngine.HistoryService.createHistoricProcessInstanceQuery().processDefinitionKey("groovy").finished().singleResult();
assertEquals(pi.Id, hpi.Id);
}
protected internal virtual void checkBusinessKeyChanged(string newBusinessKeyValue)
{
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey(PROCESS_KEY).singleResult();
assertNotNull(processInstance);
assertEquals(newBusinessKeyValue, processInstance.BusinessKey);
HistoricProcessInstance historicInstance = historyService.createHistoricProcessInstanceQuery().singleResult();
assertNotNull(historicInstance);
assertEquals(newBusinessKeyValue, historicInstance.BusinessKey);
}
public virtual void testMigrateHistoryProcessInstance()
{
//given
HistoricProcessInstanceQuery sourceHistoryProcessInstanceQuery = historyService.createHistoricProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
HistoricProcessInstanceQuery targetHistoryProcessInstanceQuery = historyService.createHistoricProcessInstanceQuery().processDefinitionId(targetProcessDefinition.Id);
//when
assertEquals(1, sourceHistoryProcessInstanceQuery.count());
assertEquals(0, targetHistoryProcessInstanceQuery.count());
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
runtimeService.newMigration(migrationPlan).processInstanceQuery(sourceProcessInstanceQuery).execute();
//then
assertEquals(0, sourceHistoryProcessInstanceQuery.count());
assertEquals(1, targetHistoryProcessInstanceQuery.count());
HistoricProcessInstance instance = targetHistoryProcessInstanceQuery.singleResult();
assertEquals(instance.ProcessDefinitionKey, targetProcessDefinition.Key);
}
// delete permission /////////////////////////////////////////////////
public virtual void checkDeleteHistoricProcessInstance(HistoricProcessInstance instance)
{
AuthorizationManager.checkAuthorization(DELETE_HISTORY, PROCESS_DEFINITION, instance.ProcessDefinitionKey);
}
