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);
}
public virtual void testProcessRefTenantIdConstant()
{
deployment(CMMN_TENANT_CONST);
deploymentForTenant(TENANT_ONE, PROCESS);
caseService.withCaseDefinitionByKey("testCase").create();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("testProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testStartProcessInstanceByKeyWithoutTenantIdNoAuthenticatedTenants()
{
identityService.setAuthentication("user", null, null);
deployment(PROCESS);
runtimeService.createProcessInstanceByKey("testProcess").processDefinitionWithoutTenantId().execute();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(1L));
}
public virtual void testStartProcessInstanceByKeyWithoutTenantId()
{
deployment(PROCESS);
deploymentForTenant(TENANT_ONE, PROCESS);
runtimeService.createProcessInstanceByKey("testProcess").processDefinitionWithoutTenantId().execute();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(1L));
assertThat(query.singleResult().TenantId, @is(nullValue()));
}
public virtual void testCalledElementTenantIdExpression()
{
BpmnModelInstance callingProcess = Bpmn.createExecutableProcess("callingProcess").startEvent().callActivity().calledElement("subProcess").camundaCalledElementTenantId("${'" + TENANT_ONE + "'}").endEvent().done();
deploymentForTenant(TENANT_ONE, SUB_PROCESS);
deployment(callingProcess);
runtimeService.startProcessInstanceByKey("callingProcess");
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("subProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testQueryByLeafInstancesOneLayer()
{
ProcessInstance process = runtimeService.startProcessInstanceByKey("simpleSubProcess");
ProcessInstanceQuery simpleSubProcessQuery = runtimeService.createProcessInstanceQuery().processDefinitionKey("simpleSubProcess");
assertThat(runtimeService.createProcessInstanceQuery().count(), @is(1L));
assertThat(simpleSubProcessQuery.count(), @is(1L));
ProcessInstance instance = runtimeService.createProcessInstanceQuery().leafProcessInstances().singleResult();
assertThat(instance.RootProcessInstanceId, @is(process.Id));
assertThat(instance.Id, @is(simpleSubProcessQuery.singleResult().Id));
}
public virtual void testStartProcessInstanceWithVersionBinding()
{
deploymentForTenant(TENANT_ONE, CMMN_VERSION, PROCESS);
deploymentForTenant(TENANT_TWO, CMMN_VERSION, PROCESS);
createCaseInstance("testCaseVersion", TENANT_ONE);
createCaseInstance("testCaseVersion", TENANT_TWO);
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("testProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(1L));
}
public virtual void testStartProcessInstanceByKeyWithTenantIdDisabledTenantCheck()
{
processEngineConfiguration.TenantCheckEnabled = false;
identityService.setAuthentication("user", null, null);
deploymentForTenant(TENANT_ONE, PROCESS);
runtimeService.createProcessInstanceByKey("testProcess").processDefinitionTenantId(TENANT_ONE).execute();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testStartProcessInstanceByKeyWithAuthenticatedTenant()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
deploymentForTenant(TENANT_ONE, PROCESS);
deploymentForTenant(TENANT_TWO, PROCESS);
runtimeService.createProcessInstanceByKey("testProcess").execute();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendProcessInstanceForNonTenant()
public virtual void suspendProcessInstanceForNonTenant()
{
// given activated process instances
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).processDefinitionWithoutTenantId().suspend();
assertThat(query.active().count(), @is(2L));
assertThat(query.suspended().count(), @is(1L));
assertThat(query.suspended().withoutTenantId().count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateMessageToStartEventDisabledTenantCheck()
public virtual void correlateMessageToStartEventDisabledTenantCheck()
{
testRule.deployForTenant(TENANT_ONE, MESSAGE_START_PROCESS);
testRule.deployForTenant(TENANT_TWO, MESSAGE_START_PROCESS);
engineRule.ProcessEngineConfiguration.TenantCheckEnabled = false;
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.createMessageCorrelation("message").tenantId(TENANT_ONE).correlateStartMessage();
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(0L));
}
public virtual void testStartProcessInstanceWithVersionBinding()
{
BpmnModelInstance callingProcess = Bpmn.createExecutableProcess("callingProcess").startEvent().callActivity().calledElement("subProcess").camundaCalledElementBinding("version").camundaCalledElementVersion("1").endEvent().done();
deploymentForTenant(TENANT_ONE, callingProcess, SUB_PROCESS);
deploymentForTenant(TENANT_TWO, callingProcess, SUB_PROCESS);
runtimeService.createProcessInstanceByKey("callingProcess").processDefinitionTenantId(TENANT_ONE).execute();
runtimeService.createProcessInstanceByKey("callingProcess").processDefinitionTenantId(TENANT_TWO).execute();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("subProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(1L));
}
public virtual void testProcessRefTenantIdExpression()
{
deployment(CMMN_TENANT_EXPR);
deploymentForTenant(TENANT_ONE, PROCESS);
caseService.withCaseDefinitionByKey("testCase").create();
CaseExecution caseExecution = caseService.createCaseExecutionQuery().activityId(PROCESS_TASK_ID).singleResult();
caseService.withCaseExecution(caseExecution.Id).manualStart();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("testProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testStartProcessInstanceByIdAuthenticatedTenant()
{
deploymentForTenant(TENANT_ONE, PROCESS);
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().singleResult();
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
runtimeService.createProcessInstanceById(processDefinition.Id).execute();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateMessageToStartEventWithAuthenticatedTenant()
public virtual void correlateMessageToStartEventWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, MESSAGE_START_PROCESS);
testRule.deployForTenant(TENANT_TWO, MESSAGE_START_PROCESS);
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.createMessageCorrelation("message").correlateStartMessage();
engineRule.IdentityService.clearAuthentication();
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sendSignalToStartEventDisabledTenantCheck()
public virtual void sendSignalToStartEventDisabledTenantCheck()
{
testRule.deployForTenant(TENANT_ONE, SIGNAL_START_PROCESS);
testRule.deployForTenant(TENANT_TWO, SIGNAL_START_PROCESS);
engineRule.ProcessEngineConfiguration.TenantCheckEnabled = false;
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.createSignalEvent("signal").send();
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sendSignalToStartEventWithAuthenticatedTenant()
public virtual void sendSignalToStartEventWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, SIGNAL_START_PROCESS);
testRule.deployForTenant(TENANT_TWO, SIGNAL_START_PROCESS);
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.createSignalEvent("signal").send();
engineRule.IdentityService.clearAuthentication();
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(0L));
}
public virtual void testStartProcessInstanceWithLatestBindingDifferentVersion()
{
deploymentForTenant(TENANT_ONE, CMMN_LATEST_WITH_MANUAL_ACTIVATION, PROCESS);
deploymentForTenant(TENANT_TWO, CMMN_LATEST_WITH_MANUAL_ACTIVATION, PROCESS);
deploymentForTenant(TENANT_TWO, PROCESS);
createCaseInstance("testCase", TENANT_ONE);
createCaseInstance("testCase", TENANT_TWO);
ProcessDefinition latestProcessTenantTwo = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_TWO).processDefinitionKey("testProcess").latestVersion().singleResult();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("testProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).processDefinitionId(latestProcessTenantTwo.Id).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendProcessInstanceDisabledTenantCheck()
public virtual void suspendProcessInstanceDisabledTenantCheck()
{
// given activated process instances
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
engineRule.ProcessEngineConfiguration.TenantCheckEnabled = false;
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).suspend();
assertThat(query.active().count(), @is(0L));
assertThat(query.suspended().count(), @is(3L));
assertThat(query.suspended().tenantIdIn(TENANT_ONE, TENANT_TWO).count(), @is(2L));
assertThat(query.suspended().withoutTenantId().count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendProcessInstanceNoAuthenticatedTenants()
public virtual void suspendProcessInstanceNoAuthenticatedTenants()
{
// given activated process instances
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).suspend();
engineRule.IdentityService.clearAuthentication();
assertThat(query.active().count(), @is(2L));
assertThat(query.suspended().count(), @is(1L));
assertThat(query.suspended().withoutTenantId().count(), @is(1L));
}
public virtual void testStartProcessInstanceWithLatestBindingDifferentVersion()
{
BpmnModelInstance callingProcess = Bpmn.createExecutableProcess("callingProcess").startEvent().callActivity().calledElement("subProcess").camundaCalledElementBinding("latest").endEvent().done();
deploymentForTenant(TENANT_ONE, callingProcess, SUB_PROCESS);
deploymentForTenant(TENANT_TWO, callingProcess, SUB_PROCESS);
deploymentForTenant(TENANT_TWO, SUB_PROCESS);
runtimeService.createProcessInstanceByKey("callingProcess").processDefinitionTenantId(TENANT_ONE).execute();
runtimeService.createProcessInstanceByKey("callingProcess").processDefinitionTenantId(TENANT_TWO).execute();
ProcessDefinition latestSubProcessTenantTwo = repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_TWO).processDefinitionKey("subProcess").latestVersion().singleResult();
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("subProcess");
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).processDefinitionId(latestSubProcessTenantTwo.Id).count(), @is(1L));
}
public virtual void testQueryByLeafInstancesTwoLayers()
{
/*
* nested structure:
* nestedSubProcess
* +-- subProcess
*/
ProcessInstance twoLayerProcess = runtimeService.startProcessInstanceByKey("nestedSimpleSubProcess");
ProcessInstanceQuery simpleSubProcessQuery = runtimeService.createProcessInstanceQuery().processDefinitionKey("simpleSubProcess");
assertThat(runtimeService.createProcessInstanceQuery().count(), @is(2L));
assertThat(runtimeService.createProcessInstanceQuery().processDefinitionKey("nestedSimpleSubProcess").count(), @is(1L));
assertThat(simpleSubProcessQuery.count(), @is(1L));
ProcessInstance instance = runtimeService.createProcessInstanceQuery().leafProcessInstances().singleResult();
assertThat(instance.RootProcessInstanceId, @is(twoLayerProcess.Id));
assertThat(instance.Id, @is(simpleSubProcessQuery.singleResult().Id));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendAndActivateProcessInstancesForAllTenants()
public virtual void suspendAndActivateProcessInstancesForAllTenants()
{
// given activated process instances
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
// first suspend
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).suspend();
assertThat(query.active().count(), @is(0L));
assertThat(query.suspended().count(), @is(3L));
// then activate
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).activate();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendProcessDefinitionByIdIncludeInstancesFromAllTenants()
public virtual void suspendProcessDefinitionByIdIncludeInstancesFromAllTenants()
{
// given active process instances with tenant id of process definition without tenant id
engineRule.RuntimeService.createProcessInstanceByKey(PROCESS_DEFINITION_KEY).processDefinitionWithoutTenantId().execute();
ProcessDefinition processDefinition = engineRule.RepositoryService.createProcessDefinitionQuery().withoutTenantId().singleResult();
ProcessInstanceQuery query = engineRule.RuntimeService.createProcessInstanceQuery().processDefinitionId(processDefinition.Id);
assertThat(query.active().count(), @is(1L));
assertThat(query.active().tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.suspended().count(), @is(0L));
// suspend all instances of process definition
engineRule.RepositoryService.updateProcessDefinitionSuspensionState().byProcessDefinitionId(processDefinition.Id).includeProcessInstances(true).suspend();
assertThat(query.active().count(), @is(0L));
assertThat(query.suspended().count(), @is(1L));
assertThat(query.suspended().tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testStartProcessInstanceWithVersionTagBinding()
{
// given
BpmnModelInstance callingProcess = createCallingProcess("callingProcess", "ver_tag_1");
deploymentForTenant(TENANT_ONE, callingProcess);
deploymentForTenant(TENANT_ONE, "org/camunda/bpm/engine/test/bpmn/callactivity/subProcessWithVersionTag.bpmn20.xml");
deploymentForTenant(TENANT_TWO, callingProcess);
deploymentForTenant(TENANT_TWO, "org/camunda/bpm/engine/test/bpmn/callactivity/subProcessWithVersionTag2.bpmn20.xml");
// when
runtimeService.createProcessInstanceByKey("callingProcess").processDefinitionTenantId(TENANT_ONE).execute();
runtimeService.createProcessInstanceByKey("callingProcess").processDefinitionTenantId(TENANT_TWO).execute();
// then
ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey("subProcess");
assertThat(query.activityIdIn("Task_1").tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.activityIdIn("Task_2").tenantIdIn(TENANT_TWO).count(), @is(1L));
}
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);
}
