//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallBpmnProcessReconfigureCallActivity()
public virtual void testCallBpmnProcessReconfigureCallActivity()
{
// given
BpmnModelInstance model = CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess");
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(model);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(model).callActivityBuilder("callActivity").calledElement("foo").done());
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then the called instance has not changed (e.g. not been migrated to a different process definition)
ProcessInstance calledInstance = rule.RuntimeService.createProcessInstanceQuery().processDefinitionKey("oneTaskProcess").singleResult();
Assert.assertNotNull(calledInstance);
// and 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 decisionRefWithCompositeExpression()
{
VariableMap variables = Variables.createVariables().putValue("version", 1);
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcessCompositeExpression", variables);
assertEquals("okay", getDecisionResult(processInstance));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableInOutMappingOfCallActivity()
public virtual void testNonInterruptingSetVariableInOutMappingOfCallActivity()
{
engine.manageDeployment(repositoryService.createDeployment().addModelInstance(CONDITIONAL_MODEL, DELEGATED_PROCESS).deploy());
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().userTask(TASK_BEFORE_CONDITION_ID).name(TASK_BEFORE_CONDITION).subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().callActivity(TASK_WITH_CONDITION_ID).calledElement(DELEGATED_PROCESS_KEY).camundaOut(VARIABLE_NAME, VARIABLE_NAME).userTask().name(TASK_AFTER_OUTPUT_MAPPING).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, false);
modelInstance = addBoundaryEvent(modelInstance, TASK_WITH_CONDITION_ID, TASK_AFTER_COND_BOUN_EVENT_IN_SUB_PROCESS, false);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
Task task = taskQuery.singleResult();
assertNotNull(task);
assertEquals(TASK_BEFORE_CONDITION, task.Name);
//when task before service task is completed
taskService.complete(task.Id);
//then out mapping of call activity sets a variable
//-> all non interrupting conditional events are triggered
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(5, tasksAfterVariableIsSet.Count);
//three subscriptions: event sub process in sub process and on process instance level and boundary event of sub process
assertEquals(3, conditionEventSubscriptionQuery.count());
}
public void execute(ProcessEngine engine, string scenarioName)
{
ProcessInstance procInstance = engine.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY, scenarioName);
Job job = engine.ManagementService.createJobQuery().processInstanceId(procInstance.Id).singleResult();
engine.ManagementService.executeJob(job.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMigrateHistoricIncidentAddScope()
public virtual void testMigrateHistoricIncidentAddScope()
{
// given
ProcessDefinition sourceProcess = testHelper.deployAndGetDefinition(AsyncProcessModels.ASYNC_BEFORE_USER_TASK_PROCESS);
ProcessDefinition targetProcess = testHelper.deployAndGetDefinition(AsyncProcessModels.ASYNC_BEFORE_SUBPROCESS_USER_TASK_PROCESS);
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcess.Id, targetProcess.Id).mapActivities("userTask", "userTask").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcess.Id);
Job job = managementService.createJobQuery().singleResult();
managementService.setJobRetries(job.Id, 0);
// when
runtimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).execute();
// then
ActivityInstance activityInstance = runtimeService.getActivityInstance(processInstance.Id);
HistoricIncident historicIncident = historyService.createHistoricIncidentQuery().singleResult();
Assert.assertNotNull(historicIncident);
Assert.assertEquals(activityInstance.getTransitionInstances("userTask")[0].ExecutionId, historicIncident.ExecutionId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testStartToEnd()
public virtual void testStartToEnd()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("startToEnd");
assertProcessEnded(processInstance.Id);
assertTrue(processInstance.Ended);
}
protected internal virtual void testDelegation()
{
TaskQuery taskQuery = taskService.createTaskQuery();
//when
Task taskInSubProcess = taskQuery.singleResult();
assertEquals("Task in subprocess", taskInSubProcess.Name);
//then check value from input variable
object inputVar = runtimeService.getVariable(taskInSubProcess.ProcessInstanceId, "TestInputVar");
assertEquals("inValue", inputVar);
//when completing the task in the subprocess, finishes the subprocess
taskService.complete(taskInSubProcess.Id);
Task taskAfterSubProcess = taskQuery.singleResult();
assertEquals("Task after subprocess", taskAfterSubProcess.Name);
//then check value from output variable
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().singleResult();
object outputVar = runtimeService.getVariable(processInstance.Id, "TestOutputVar");
assertEquals("outValue", outputVar);
//complete task after sub process
taskService.complete(taskAfterSubProcess.Id);
}
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 void execute(ProcessEngine engine, string scenarioName)
{
ProcessInstance procInst = engine.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY_2, scenarioName);
Task task = engine.TaskService.createTaskQuery().processInstanceId(procInst.Id).singleResult();
engine.TaskService.complete(task.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCustomIncidentMigrationWithoutConfiguration()
public virtual void testCustomIncidentMigrationWithoutConfiguration()
{
// given
RuntimeService runtimeService = engineRule.RuntimeService;
BpmnModelInstance instance1 = Bpmn.createExecutableProcess("process1").startEvent().userTask("u1").endEvent().done();
BpmnModelInstance instance2 = Bpmn.createExecutableProcess("process2").startEvent().userTask("u2").endEvent().done();
testHelper.deploy(instance1, instance2);
ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("process1");
ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("process2");
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(processInstance1.ProcessDefinitionId, processInstance2.ProcessDefinitionId).mapActivities("u1", "u2").build();
runtimeService.createIncident("custom", processInstance1.Id, null);
// when
runtimeService.newMigration(migrationPlan).processInstanceIds(processInstance1.Id).execute();
// then
Incident incident = runtimeService.createIncidentQuery().singleResult();
assertEquals(processInstance2.ProcessDefinitionId, incident.ProcessDefinitionId);
assertEquals("custom", incident.IncidentType);
assertEquals(processInstance1.Id, incident.ExecutionId);
}
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 testJobIncidentMigration()
public virtual void testJobIncidentMigration()
{
// Given we deploy process definitions
testHelper.deploy(FAIL_CALLED_PROC, NEW_CALLED_PROC);
ProcessDefinition failingProcess = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey(FAIL_CALLED_PROC_KEY).singleResult();
ProcessDefinition newProcess = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey(NEW_CALLED_PROC_KEY).singleResult();
//create process instance and execute job which fails
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey(FAIL_CALLED_PROC_KEY);
testHelper.executeAvailableJobs();
Incident incidentInCallingProcess = engineRule.RuntimeService.createIncidentQuery().processDefinitionId(failingProcess.Id).singleResult();
// when
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(failingProcess.Id, newProcess.Id).mapEqualActivities().mapActivities("task", "taskV2").build();
engineRule.RuntimeService.newMigration(migrationPlan).processInstanceIds(processInstance.Id).execute();
// then
Incident incidentAfterMigration = engineRule.RuntimeService.createIncidentQuery().incidentId(incidentInCallingProcess.Id).singleResult();
Assert.assertEquals(newProcess.Id, incidentAfterMigration.ProcessDefinitionId);
Assert.assertEquals("taskV2", incidentAfterMigration.ActivityId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testExecuteExclusiveFollowUpJobInDifferentProcessInstance()
public virtual void testExecuteExclusiveFollowUpJobInDifferentProcessInstance()
{
testHelper.deploy(CALL_ACTIVITY_PROCESS, ONE_TASK_PROCESS);
// given
// a process instance with a single job
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey("callActivityProcess");
jobExecutor.start();
// and first job acquisition that acquires the job
acquisitionThread.waitForSync();
acquisitionThread.makeContinueAndWaitForSync();
// and job is executed
acquisitionThread.makeContinueAndWaitForSync();
// then
// the called instance has been created
ProcessInstance calledInstance = engineRule.RuntimeService.createProcessInstanceQuery().superProcessInstanceId(processInstance.Id).singleResult();
Assert.assertNotNull(calledInstance);
// and there is a transition instance for the service task
ActivityInstance activityInstance = engineRule.RuntimeService.getActivityInstance(calledInstance.Id);
Assert.assertEquals(1, activityInstance.getTransitionInstances("serviceTask").Length);
// but the corresponding job is not locked
JobEntity followUpJob = (JobEntity)engineRule.ManagementService.createJobQuery().singleResult();
Assert.assertNotNull(followUpJob);
Assert.assertNull(followUpJob.LockOwner);
Assert.assertNull(followUpJob.LockExpirationTime);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallBpmnProcessSimpleMigration()
public virtual void testCallBpmnProcessSimpleMigration()
{
// given
BpmnModelInstance model = CallActivityModels.oneBpmnCallActivityProcess("oneTaskProcess");
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(model);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(model);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.assertExecutionTreeAfterMigration().hasProcessDefinitionId(targetProcessDefinition.Id).matches(describeExecutionTree(null).scope().id(testHelper.snapshotBeforeMigration.ProcessInstanceId).child("callActivity").scope().id(testHelper.getSingleExecutionIdForActivityBeforeMigration("callActivity")).done());
testHelper.assertActivityTreeAfterMigration().hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).activity("callActivity", testHelper.getSingleActivityInstanceBeforeMigration("callActivity").Id).done());
// and 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 testInitThrowUnhandledException()
{
// given
ProcessInstance instance = rule.processInstance();
Task eventSubProcessTask = rule.taskQuery().taskDefinitionKey("eventSubProcessTask").singleResult();
// when
rule.TaskService.complete(eventSubProcessTask.Id);
// and
rule.RuntimeService.setVariable(instance.Id, ThrowBpmnErrorDelegate.EXCEPTION_INDICATOR_VARIABLE, true);
rule.RuntimeService.setVariable(instance.Id, ThrowBpmnErrorDelegate.EXCEPTION_MESSAGE_VARIABLE, "unhandledException");
Task innerSubProcessTask = rule.taskQuery().taskDefinitionKey("innerSubProcessTask").singleResult();
Assert.assertNotNull(innerSubProcessTask);
// then
try
{
rule.TaskService.complete(innerSubProcessTask.Id);
Assert.fail("should throw a ThrowBpmnErrorDelegateException");
}
catch (ThrowBpmnErrorDelegate.ThrowBpmnErrorDelegateException e)
{
Assert.assertEquals("unhandledException", e.Message);
}
}
public virtual void testSerializationOfUnknownFormat()
{
// given
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
// when
ObjectValue objectValue = Variables.serializedObjectValue("foo").serializationDataFormat("application/foo").objectTypeName("org.camunda.Foo").create();
runtimeService.setVariable(instance.Id, "var", objectValue);
// then
try
{
runtimeService.getVariable(instance.Id, "var");
fail();
}
catch (ProcessEngineException e)
{
assertTextPresent("Fallback serializer cannot handle deserialized objects", e.Message);
}
ObjectValue returnedValue = runtimeService.getVariableTyped(instance.Id, "var", false);
assertFalse(returnedValue.Deserialized);
assertEquals("application/foo", returnedValue.SerializationDataFormat);
assertEquals("foo", returnedValue.ValueSerialized);
assertEquals("org.camunda.Foo", returnedValue.ObjectTypeName);
}
/// <summary>
/// Ensures that situations are avoided in which more tokens end up at the target gateway
/// than it has incoming flows
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testAddGatewayIncomingSequenceFlow()
public virtual void testAddGatewayIncomingSequenceFlow()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(GatewayModels.PARALLEL_GW);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(GatewayModels.PARALLEL_GW).flowNodeBuilder("fork").userTask("parallel3").connectTo("join").done());
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
testHelper.completeTask("parallel2");
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("parallel1", "parallel1").mapActivities("join", "join").build();
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
Assert.assertEquals(1, rule.TaskService.createTaskQuery().count());
Assert.assertEquals(0, rule.TaskService.createTaskQuery().taskDefinitionKey("afterJoin").count());
rule.RuntimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("join").execute();
Assert.assertEquals(0, rule.TaskService.createTaskQuery().taskDefinitionKey("afterJoin").count());
testHelper.completeTask("parallel1");
testHelper.completeTask("afterJoin");
testHelper.assertProcessEnded(processInstance.Id);
}
public virtual void testReceivesNoHistoricVariableUpdatesAsDetails()
{
// given
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
// when
string value = "a Variable Value";
runtimeService.setVariable(instance.Id, "aStringVariable", value);
runtimeService.setVariable(instance.Id, "aBytesVariable", value.GetBytes());
string newValue = "a new Variable Value";
runtimeService.setVariable(instance.Id, "aStringVariable", newValue);
runtimeService.setVariable(instance.Id, "aBytesVariable", newValue.GetBytes());
// then the historic variable instances exist and they have the latest values
assertEquals(2, historyService.createHistoricVariableInstanceQuery().count());
HistoricVariableInstance historicStringVariable = historyService.createHistoricVariableInstanceQuery().variableName("aStringVariable").singleResult();
assertNotNull(historicStringVariable);
assertEquals(newValue, historicStringVariable.Value);
HistoricVariableInstance historicBytesVariable = historyService.createHistoricVariableInstanceQuery().variableName("aBytesVariable").singleResult();
assertNotNull(historicBytesVariable);
assertTrue(Arrays.Equals(newValue.GetBytes(), (sbyte[])historicBytesVariable.Value));
// and no historic details exist
assertEquals(0, historyService.createHistoricDetailQuery().variableUpdates().count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariablesInParentEventScopeStillAccessible()
public virtual void testVariablesInParentEventScopeStillAccessible()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.DOUBLE_SUBPROCESS_MODEL);
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("subProcess", "outerSubProcess").mapActivities("compensationBoundary", "compensationBoundary").mapActivities("userTask2", "userTask2").build();
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
Execution subProcessExecution = rule.RuntimeService.createExecutionQuery().activityId("userTask1").singleResult();
rule.RuntimeService.setVariableLocal(subProcessExecution.Id, "foo", "bar");
testHelper.completeTask("userTask1");
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// when throwing compensation
testHelper.completeAnyTask("userTask2");
// then the variable snapshot is available
Task compensationTask = rule.TaskService.createTaskQuery().singleResult();
Assert.assertEquals("bar", rule.TaskService.getVariable(compensationTask.Id, "foo"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMigrateCompensationSubscriptionAddRemoveSubProcess()
public virtual void testMigrateCompensationSubscriptionAddRemoveSubProcess()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
// subProcess is not mapped
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask2", "userTask2").mapActivities("compensationBoundary", "compensationBoundary").build();
ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id);
testHelper.completeTask("userTask1");
// when
testHelper.migrateProcessInstance(migrationPlan, processInstance);
// then
testHelper.assertEventSubscriptionMigrated("compensationHandler", "compensationHandler", null);
// and the compensation can be triggered and completed
testHelper.completeTask("userTask2");
testHelper.completeTask("compensationHandler");
testHelper.assertProcessEnded(processInstance.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFallbackSerializerDoesNotOverrideRegularSerializer()
public virtual void testFallbackSerializerDoesNotOverrideRegularSerializer()
{
// given
// that the process engine is configured with a serializer for a certain format
// and a fallback serializer factory for the same format
ProcessEngineConfigurationImpl engineConfiguration = (new StandaloneInMemProcessEngineConfiguration()).setJdbcUrl("jdbc:h2:mem:camunda-forceclose").setProcessEngineName("engine-forceclose");
engineConfiguration.CustomPreVariableSerializers = Arrays.asList <TypedValueSerializer>(new ExampleConstantSerializer());
engineConfiguration.FallbackSerializerFactory = new ExampleSerializerFactory();
processEngine = engineConfiguration.buildProcessEngine();
deployOneTaskProcess(processEngine);
// when setting a variable that no regular serializer can handle
ObjectValue objectValue = Variables.objectValue("foo").serializationDataFormat(ExampleSerializer.FORMAT).create();
ProcessInstance pi = processEngine.RuntimeService.startProcessInstanceByKey("oneTaskProcess", Variables.createVariables().putValueTyped("var", objectValue));
ObjectValue fetchedValue = processEngine.RuntimeService.getVariableTyped(pi.Id, "var", true);
// then the fallback serializer is used
Assert.assertNotNull(fetchedValue);
Assert.assertEquals(ExampleSerializer.FORMAT, fetchedValue.SerializationDataFormat);
Assert.assertEquals(ExampleConstantSerializer.DESERIALIZED_VALUE, fetchedValue.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSuspensionWithTenancy() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testSuspensionWithTenancy()
{
BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().userTask().endEvent().done();
ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance);
ProcessDefinition processDefinition1 = processEngineTestRule.deployForTenantAndGetDefinition(TENANT_ONE, instance);
ProcessDefinition processDefinition2 = processEngineTestRule.deployForTenantAndGetDefinition(TENANT_TWO, instance);
ProcessInstance processInstance = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id);
ProcessInstance processInstance1 = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition1.Id);
ProcessInstance processInstance2 = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition2.Id);
//suspend Tenant one
processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(processDefinition1.Key).processDefinitionTenantId(processDefinition1.TenantId).suspend();
string[] processInstances = new string[] { processInstance1.Id, processInstance2.Id, processInstance.Id };
verifyStates(processInstances, new string[] { org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED, org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE, org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE });
//suspend without tenant
processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(processDefinition.Key).processDefinitionWithoutTenantId().suspend();
verifyStates(processInstances, new string[] { org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED, org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE, org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED });
//reactivate without tenant
processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(processDefinition.Key).processDefinitionWithoutTenantId().activate();
verifyStates(processInstances, new string[] { org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED, org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE, org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE });
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeployProcessWithoutIsExecutableAttribute()
public virtual void testDeployProcessWithoutIsExecutableAttribute()
{
RuntimeService runtimeService = engineRule.RuntimeService;
ProcessInstance procInstance = runtimeService.startProcessInstanceByKey("processWithoutIsExecutableAttribute");
Assert.assertNotNull(procInstance);
}
public virtual void testSerializationAsJava()
{
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
JavaSerializable bean = new JavaSerializable("a String", 42, true);
// request object to be serialized as Java
runtimeService.setVariable(instance.Id, "simpleBean", objectValue(bean).serializationDataFormat(Variables.SerializationDataFormats.JAVA).create());
// validate untyped value
object value = runtimeService.getVariable(instance.Id, "simpleBean");
assertEquals(bean, value);
// validate typed value
ObjectValue typedValue = runtimeService.getVariableTyped(instance.Id, "simpleBean");
assertEquals(ValueType.OBJECT, typedValue.Type);
assertTrue(typedValue.Deserialized);
assertEquals(bean, typedValue.Value);
assertEquals(bean, typedValue.getValue(typeof(JavaSerializable)));
assertEquals(typeof(JavaSerializable), typedValue.ObjectType);
assertEquals(Variables.SerializationDataFormats.JAVA.Name, typedValue.SerializationDataFormat);
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
assertEquals(typeof(JavaSerializable).FullName, typedValue.ObjectTypeName);
}
public virtual void testPojo()
{
VariableMap variables = Variables.createVariables().putValue("pojo", new TestPojo("okay", 13.37));
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcess", variables);
assertEquals("okay", getDecisionResult(processInstance));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: protected org.camunda.bpm.engine.impl.runtime.MessageCorrelationResultImpl createMessageCorrelationResult(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext, final org.camunda.bpm.engine.impl.runtime.CorrelationHandlerResult handlerResult)
protected internal virtual MessageCorrelationResultImpl createMessageCorrelationResult(CommandContext commandContext, CorrelationHandlerResult handlerResult)
{
MessageCorrelationResultImpl resultWithVariables = new MessageCorrelationResultImpl(handlerResult);
if (MessageCorrelationResultType.Execution.Equals(handlerResult.ResultType))
{
ExecutionEntity execution = findProcessInstanceExecution(commandContext, handlerResult);
if (variablesEnabled && execution != null)
{
variablesListener = new ExecutionVariableSnapshotObserver(execution, false, deserializeVariableValues);
}
triggerExecution(commandContext, handlerResult);
}
else
{
ProcessInstance instance = instantiateProcess(commandContext, handlerResult);
resultWithVariables.ProcessInstance = instance;
}
if (variablesListener != null)
{
resultWithVariables.Variables = variablesListener.Variables;
}
return(resultWithVariables);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @OperateOnDeployment("pa") public void testRequestContextPropagationEjbLocal() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testRequestContextPropagationEjbLocal()
{
// This fails with WELD-001303 No active contexts for scope type javax.enterprise.context.RequestScoped as well
// InvocationCounterServiceLocal service = InitialContext.doLookup("java:/" +
// "global/" +
// "service/" +
// "InvocationCounterServiceBean!org.camunda.bpm.integrationtest.functional.cdi.beans.InvocationCounterServiceLocal");
//
// service.getNumOfInvocations();
ProcessInstance pi = runtimeService.startProcessInstanceByKey("testContextPropagationEjbLocal");
waitForJobExecutorToProcessAllJobs();
object variable = runtimeService.getVariable(pi.Id, "invocationCounter");
// -> the same bean instance was invoked 2 times!
Assert.assertEquals(2, variable);
Task task = taskService.createTaskQuery().processInstanceId(pi.ProcessInstanceId).singleResult();
taskService.complete(task.Id);
waitForJobExecutorToProcessAllJobs();
variable = runtimeService.getVariable(pi.Id, "invocationCounter");
// now it's '1' again! -> new instance of the bean
Assert.assertEquals(1, variable);
}
public virtual void testInitThrowError()
{
// given
ProcessInstance instance = rule.processInstance();
Task eventSubProcessTask = rule.taskQuery().taskDefinitionKey("eventSubProcessTask").singleResult();
// when
rule.TaskService.complete(eventSubProcessTask.Id);
// and
rule.RuntimeService.setVariable(instance.Id, ThrowBpmnErrorDelegate.ERROR_INDICATOR_VARIABLE, true);
Task innerSubProcessTask = rule.taskQuery().taskDefinitionKey("innerSubProcessTask").singleResult();
Assert.assertNotNull(innerSubProcessTask);
rule.TaskService.complete(innerSubProcessTask.Id);
// then
Task afterErrorTask = rule.taskQuery().singleResult();
Assert.assertNotNull(afterErrorTask);
Assert.assertEquals("escalatedTask", afterErrorTask.TaskDefinitionKey);
// and
rule.TaskService.complete(afterErrorTask.Id);
rule.assertScenarioEnded();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDontWriteDuplicateLogOnBatchMigrationJobExecution()
public virtual void testDontWriteDuplicateLogOnBatchMigrationJobExecution()
{
// given
ProcessDefinition sourceDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceDefinition.Id);
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceDefinition.Id, targetDefinition.Id).mapEqualActivities().build();
batch = runtimeService.newMigration(migrationPlan).processInstanceIds(Arrays.asList(processInstance.Id)).executeAsync();
Job seedJob = managementService.createJobQuery().singleResult();
managementService.executeJob(seedJob.Id);
Job migrationJob = managementService.createJobQuery().jobDefinitionId(batch.BatchJobDefinitionId).singleResult();
// when
managementService.executeJob(migrationJob.Id);
// then
assertEquals(9, userOperationLogQuery().count());
assertEquals(2, userOperationLogQuery().operationType(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE).entityType(EntityTypes.DEPLOYMENT).count());
assertEquals(1, userOperationLogQuery().operationType(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE).entityType(EntityTypes.PROCESS_INSTANCE).count());
assertEquals(3, userOperationLogQuery().operationType(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_MIGRATE).entityType(EntityTypes.PROCESS_INSTANCE).count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallCmmnCaseSequentialMultiInstanceRemoveMiBody()
public virtual void testCallCmmnCaseSequentialMultiInstanceRemoveMiBody()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(modify(CallActivityModels.oneCmmnCallActivityProcess("oneTaskCase")).activityBuilder("callActivity").multiInstance().sequential().cardinality("1").done());
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CallActivityModels.oneCmmnCallActivityProcess("oneTaskCase"));
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.assertExecutionTreeAfterMigration().hasProcessDefinitionId(targetProcessDefinition.Id).matches(describeExecutionTree(null).scope().id(testHelper.snapshotBeforeMigration.ProcessInstanceId).child("callActivity").scope().done());
testHelper.assertActivityTreeAfterMigration().hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).activity("callActivity", testHelper.getSingleActivityInstanceBeforeMigration("callActivity").Id).done());
// then the link between calling and called instance is maintained correctly
testHelper.assertSuperExecutionOfCaseInstance(rule.CaseService.createCaseInstanceQuery().caseDefinitionKey("oneTaskCase").singleResult().Id, testHelper.getSingleExecutionIdForActivityAfterMigration("callActivity"));
// and it is possible to complete the called case instance
CaseExecution caseExecution = rule.CaseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
testHelper.completeTask("PI_HumanTask_1");
// and the calling process instance
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
// and close the called case instance
rule.CaseService.withCaseExecution(caseExecution.CaseInstanceId).close();
testHelper.assertCaseEnded(caseExecution.CaseInstanceId);
}
