//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); }