public virtual void testScopeTaskStartBefore() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess"); string processInstanceId = processInstance.Id; Batch modificationBatch = runtimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("theTask").executeAsync(); assertNotNull(modificationBatch); executeSeedAndBatchJobs(modificationBatch); ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("theTask").activity("theTask").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).concurrent().noScope().child("theTask").scope().up().up().child(null).concurrent().noScope().child("theTask").scope().done()); assertEquals(2, taskService.createTaskQuery().count()); completeTasksInOrder("theTask", "theTask"); assertProcessEnded(processInstanceId); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtParentScopeExecutionAndScopeExecutionBecomeNonScope() public virtual void testVariableAtParentScopeExecutionAndScopeExecutionBecomeNonScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ONE_BOUNDARY_TASK); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine); ExecutionTree scopeExecution = executionTreeBeforeMigration.getLeafExecutions("userTask")[0]; runtimeService.setVariableLocal(scopeExecution.Id, "foo", "userTaskScopeValue"); runtimeService.setVariableLocal(processInstance.Id, "foo", "processScopeValue"); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then the process scope variable was overwritten due to a compacted execution tree Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count); VariableInstance variable = testHelper.snapshotAfterMigration.getVariables().GetEnumerator().next(); Assert.assertEquals("userTaskScopeValue", variable.Value); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtConcurrentExecutionAddParentScopeBecomeNonConcurrent() public virtual void testVariableAtConcurrentExecutionAddParentScopeBecomeNonConcurrent() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.PARALLEL_TASK_AND_SUBPROCESS_PROCESS).activityBuilder("subProcess").camundaInputParameter("foo", "subProcessValue").done()); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask1", "userTask1").mapActivities("userTask2", "userTask2").build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine); ExecutionTree task1CcExecution = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0]; ExecutionTree task2CcExecution = executionTreeBeforeMigration.getLeafExecutions("userTask2")[0]; runtimeService.setVariableLocal(task1CcExecution.Id, "foo", "task1Value"); runtimeService.setVariableLocal(task2CcExecution.Id, "foo", "task2Value"); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then the io mapping variable was overwritten due to a compacted execution tree Assert.assertEquals(2, testHelper.snapshotAfterMigration.getVariables().Count); IList <string> values = new List <string>(); foreach (VariableInstance variable in testHelper.snapshotAfterMigration.getVariables()) { values.Add((string)variable.Value); } Assert.assertTrue(values.Contains("task1Value")); Assert.assertTrue(values.Contains("task2Value")); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtConcurrentExecutionBecomeScope() public virtual void testVariableAtConcurrentExecutionBecomeScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_SCOPE_TASKS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine); ExecutionTree concurrentExecution = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0]; runtimeService.setVariableLocal(concurrentExecution.Id, "foo", 42); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then VariableInstance beforeMigration = testHelper.snapshotBeforeMigration.getSingleVariable("foo"); ExecutionTree userTask1CCExecution = testHelper.snapshotAfterMigration.ExecutionTree.getLeafExecutions("userTask1")[0].Parent; Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count); testHelper.assertVariableMigratedToExecution(beforeMigration, userTask1CCExecution.Id); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtConcurrentAndScopeExecutionBecomeNonScope() public virtual void testVariableAtConcurrentAndScopeExecutionBecomeNonScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine); ExecutionTree scopeExecution = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0]; ExecutionTree concurrentExecution = scopeExecution.Parent; runtimeService.setVariableLocal(scopeExecution.Id, "foo", 42); runtimeService.setVariableLocal(concurrentExecution.Id, "foo", 42); // when try { testHelper.migrateProcessInstance(migrationPlan, processInstance); Assert.fail("expected exception"); } catch (ProcessEngineException e) { Assert.assertThat(e.Message, CoreMatchers.containsString("The variable 'foo' exists in both, this scope" + " and concurrent local in the parent scope. Migrating to a non-scope activity would overwrite one of them.")); } }
public virtual void testVariableAtParentScopeExecutionAndScopeExecutionBecomeNonScope() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.OneTaskProcess); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapEqualActivities() .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var scopeExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask")[0]; runtimeService.SetVariableLocal(scopeExecution.Id, "foo", "userTaskScopeValue"); runtimeService.SetVariableLocal(processInstance.Id, "foo", "processScopeValue"); // when testHelper.MigrateProcessInstance(migrationPlan, processInstance); // then the process scope variable was overwritten due to a compacted execution tree Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables() .Count); var variable = testHelper.SnapshotAfterMigration.GetVariables() .GetEnumerator() .Current; Assert.AreEqual("userTaskScopeValue", variable.Value); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtScopeExecutionBecomeNonScope() public virtual void testVariableAtScopeExecutionBecomeNonScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ONE_BOUNDARY_TASK); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine); ExecutionTree scopeExecution = executionTreeBeforeMigration.Executions[0]; runtimeService.setVariableLocal(scopeExecution.Id, "foo", 42); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then VariableInstance beforeMigration = testHelper.snapshotBeforeMigration.getSingleVariable("foo"); Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count); testHelper.assertVariableMigratedToExecution(beforeMigration, processInstance.Id); // and the variable is concurrent local, i.e. expands on tree expansion runtimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("userTask").execute(); VariableInstance variableAfterExpansion = runtimeService.createVariableInstanceQuery().singleResult(); Assert.assertNotNull(variableAfterExpansion); Assert.assertNotSame(processInstance.Id, variableAfterExpansion.ExecutionId); }
public virtual void testCancelInnerActivityParallelTasksAllButOne() { // given ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("miParallelUserTasks"); completeTasksInOrder("beforeTask"); // when ActivityInstance tree = runtimeService.getActivityInstance(processInstance.Id); runtimeService.createProcessInstanceModification(processInstance.Id).cancelActivityInstance(tree.getActivityInstances("miTasks")[0].Id).cancelActivityInstance(tree.getActivityInstances("miTasks")[1].Id).execute(); // then tree = runtimeService.getActivityInstance(processInstance.Id); assertThat(tree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).beginMiBody("miTasks").activity("miTasks").endScope().done()); // the execution tree should still be in the expected shape ExecutionTree executionTree = ExecutionTree.forExecution(processInstance.Id, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).scope().child("miTasks").concurrent().noScope().done()); // and the process is able to complete successfully completeTasksInOrder("miTasks", "afterTask"); assertProcessEnded(processInstance.Id); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtConcurrentExecutionInScopeActivityRemoveParentScope() public virtual void testVariableAtConcurrentExecutionInScopeActivityRemoveParentScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(SUBPROCESS_CONCURRENT_BOUNDARY_TASKS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask1", "userTask1").mapActivities("userTask2", "userTask2").build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExecutionTree executionTreeBeforeMigration = ExecutionTree.forExecution(processInstance.Id, rule.ProcessEngine); ExecutionTree userTask1CCExecutionBefore = executionTreeBeforeMigration.getLeafExecutions("userTask1")[0].Parent; runtimeService.setVariableLocal(userTask1CCExecutionBefore.Id, "foo", 42); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then VariableInstance beforeMigration = testHelper.snapshotBeforeMigration.getSingleVariable("foo"); ExecutionTree userTask1CCExecutionAfter = testHelper.snapshotAfterMigration.ExecutionTree.getLeafExecutions("userTask1")[0].Parent; Assert.assertEquals(1, testHelper.snapshotAfterMigration.getVariables().Count); // for variables at concurrent executions that are parent of a leaf-scope-execution, the activity instance is // the activity instance id of the parent activity instance (which is probably a bug) testHelper.assertVariableMigratedToExecution(beforeMigration, userTask1CCExecutionAfter.Id, processInstance.Id); }
public virtual void noHistoryUpdateOnSameStructureMigration() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapEqualActivities() .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var scopeExecution = executionTreeBeforeMigration.Executions[0]; runtimeService.SetVariableLocal(scopeExecution.Id, "foo", 42); // when testHelper.MigrateProcessInstance(migrationPlan, processInstance); // then there is still one historic variable instance Assert.AreEqual(1, historyService.CreateHistoricVariableInstanceQuery() .Count()); // and no additional historic details Assert.AreEqual(1, historyService.CreateHistoricDetailQuery() .Count()); }
public virtual void testStartBeforeInnerActivityWithMiBodySequentialSubprocess() { // given the mi body is not yet instantiated ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("miSequentialSubprocess"); // when ActivityInstance tree = runtimeService.getActivityInstance(processInstance.Id); runtimeService.createProcessInstanceModification(processInstance.Id).startBeforeActivity("subProcessTask").execute(); // then the mi variables should be correct Execution leafExecution = runtimeService.createExecutionQuery().activityId("subProcessTask").singleResult(); assertNotNull(leafExecution); assertVariable(leafExecution, "loopCounter", 0); assertVariable(leafExecution, "nrOfInstances", 1); assertVariable(leafExecution, "nrOfCompletedInstances", 0); assertVariable(leafExecution, "nrOfActiveInstances", 1); // and the trees should be correct tree = runtimeService.getActivityInstance(processInstance.Id); assertThat(tree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("beforeTask").beginMiBody("miSubProcess").beginScope("miSubProcess").activity("subProcessTask").endScope().done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstance.Id, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child("beforeTask").concurrent().noScope().up().child(null).concurrent().noScope().child(null).scope().child("subProcessTask").scope().done()); // and the process is able to complete successfully completeTasksInOrder("subProcessTask", "afterTask", "beforeTask", "subProcessTask", "subProcessTask", "subProcessTask", "afterTask"); assertProcessEnded(processInstance.Id); }
public virtual void noHistoryUpdateOnAddScopeMigration() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS); var targetProcessDefinition = testHelper.DeployAndGetDefinition(SUBPROCESS_CONCURRENT_BOUNDARY_TASKS); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapActivities("userTask1", "userTask1") .MapActivities("userTask2", "userTask2") .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var userTask1CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0].Parent; runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", 42); // when testHelper.MigrateProcessInstance(migrationPlan, processInstance); // then there is still one historic variable instance Assert.AreEqual(1, historyService.CreateHistoricVariableInstanceQuery() .Count()); // and no additional historic details Assert.AreEqual(1, historyService.CreateHistoricDetailQuery() .Count()); }
public virtual void testCancellationAndStartBefore() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("exclusiveGateway"); string processInstanceId = processInstance.Id; ActivityInstance tree = runtimeService.getActivityInstance(processInstance.Id); Batch modificationBatch = runtimeService.createProcessInstanceModification(processInstance.Id).cancelActivityInstance(getInstanceIdForActivity(tree, "task1")).startBeforeActivity("task2").executeAsync(); assertNotNull(modificationBatch); executeSeedAndBatchJobs(modificationBatch); ActivityInstance activityInstanceTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(activityInstanceTree); assertEquals(processInstanceId, activityInstanceTree.ProcessInstanceId); assertThat(activityInstanceTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("task2").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree("task2").scope().done()); completeTasksInOrder("task2"); assertProcessEnded(processInstanceId); }
public virtual void testStartAfterActivityListenerInvocation() { RecorderExecutionListener.clear(); ProcessInstance instance = runtimeService.startProcessInstanceByKey("transitionListenerProcess", Variables.createVariables().putValue("listener", new RecorderExecutionListener())); Batch modificationBatch = runtimeService.createProcessInstanceModification(instance.Id).startTransition("flow2").executeAsync(); assertNotNull(modificationBatch); executeSeedAndBatchJobs(modificationBatch); // transition listener should have been invoked IList <RecorderExecutionListener.RecordedEvent> events = RecorderExecutionListener.RecordedEvents; assertEquals(1, events.Count); RecorderExecutionListener.RecordedEvent @event = events[0]; assertEquals("flow2", @event.TransitionId); RecorderExecutionListener.clear(); ActivityInstance updatedTree = runtimeService.getActivityInstance(instance.Id); assertNotNull(updatedTree); assertEquals(instance.Id, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(instance.ProcessDefinitionId).activity("task1").activity("task2").done()); ExecutionTree executionTree = ExecutionTree.forExecution(instance.Id, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task1").concurrent().noScope().up().child("task2").concurrent().noScope().done()); completeTasksInOrder("task1", "task2", "task2"); assertProcessEnded(instance.Id); }
public virtual void testVariableAtConcurrentExecutionBecomeScope() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ScopeTaskProcess); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapEqualActivities() .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var concurrentExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0]; runtimeService.SetVariableLocal(concurrentExecution.Id, "foo", 42); // when testHelper.MigrateProcessInstance(migrationPlan, processInstance); // then var beforeMigration = testHelper.SnapshotBeforeMigration.GetSingleVariable("foo"); var userTask1CCExecution = testHelper.SnapshotAfterMigration.ExecutionTree.GetLeafExecutions("userTask1")[0].Parent; Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables() .Count); testHelper.AssertVariableMigratedToExecution(beforeMigration, userTask1CCExecution.Id); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testVariableAtTaskAndConcurrentExecutionAddParentScope() public virtual void testVariableAtTaskAndConcurrentExecutionAddParentScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.PARALLEL_GATEWAY_SUBPROCESS_PROCESS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask1", "userTask1").mapActivities("userTask2", "userTask2").build(); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); Task task = taskService.createTaskQuery().taskDefinitionKey("userTask1").singleResult(); taskService.setVariableLocal(task.Id, "foo", 42); runtimeService.setVariableLocal(task.ExecutionId, "foo", 52); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then VariableInstance taskVarBeforeMigration = testHelper.snapshotBeforeMigration.getSingleTaskVariable(task.Id, "foo"); ExecutionTree userTask1ExecutionAfter = testHelper.snapshotAfterMigration.ExecutionTree.getLeafExecutions("userTask1")[0]; Assert.assertEquals(2, testHelper.snapshotAfterMigration.getVariables().Count); testHelper.assertVariableMigratedToExecution(taskVarBeforeMigration, userTask1ExecutionAfter.Id); }
public virtual void testVariableAtConcurrentAndScopeExecutionBecomeNonScope() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(CONCURRENT_BOUNDARY_TASKS); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapEqualActivities() .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var scopeExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0]; var concurrentExecution = scopeExecution.Parent; runtimeService.SetVariableLocal(scopeExecution.Id, "foo", 42); runtimeService.SetVariableLocal(concurrentExecution.Id, "foo", 42); // when try { testHelper.MigrateProcessInstance(migrationPlan, processInstance); Assert.Fail("expected exception"); } catch (ProcessEngineException e) { Assert.That(e.Message, Does.Contain("The variable 'foo' exists in both, this scope" + " and concurrent local in the parent scope. Migrating to a non-scope activity would overwrite one of them.")); } }
public virtual void testStartBeforeEventSubProcessInsideSubProcessTask2ShouldBeCancelled() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); string processInstanceId = processInstance.Id; string taskId = taskService.createTaskQuery().singleResult().Id; taskService.complete(taskId); runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("eventSubProcess").execute(); ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).beginScope("subProcess").beginScope("eventSubProcess").activity("eventSubProcessTask").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).scope().child("eventSubProcessTask").scope().done()); completeTasksInOrder("eventSubProcessTask"); assertProcessEnded(processInstanceId); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCancelConcurrentExecutionInCallingProcess() public virtual void shouldCancelConcurrentExecutionInCallingProcess() { // given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance parentProcessInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess("parentProcess").startEvent().parallelGateway("split").callActivity("callActivity").calledElement("subprocess").endEvent().moveToLastGateway().userTask("parentUserTask").endEvent().done(); BpmnModelInstance parentProcessInstance = Bpmn.createExecutableProcess("parentProcess").startEvent().parallelGateway("split").callActivity("callActivity").calledElement("subprocess").endEvent().moveToLastGateway().userTask("parentUserTask").endEvent().done(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance subprocessInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess("subprocess").startEvent().userTask("childUserTask").endEvent("subEnd").done(); BpmnModelInstance subprocessInstance = Bpmn.createExecutableProcess("subprocess").startEvent().userTask("childUserTask").endEvent("subEnd").done(); testHelper.deploy(parentProcessInstance, subprocessInstance); ProcessInstance callingInstance = runtimeService.startProcessInstanceByKey("parentProcess"); ProcessInstance calledInstance = runtimeService.createProcessInstanceQuery().superProcessInstanceId(callingInstance.Id).singleResult(); // when runtimeService.createProcessInstanceModification(calledInstance.Id).cancelAllForActivity("childUserTask").execute(); // then ProcessInstance calledInstanceAfterModification = runtimeService.createProcessInstanceQuery().processInstanceId(calledInstance.Id).singleResult(); Assert.assertNull(calledInstanceAfterModification); ExecutionTree executionTree = ExecutionTree.forExecution(callingInstance.Id, rule.ProcessEngine); assertThat(executionTree).matches(describeExecutionTree("parentUserTask").scope().done()); }
public virtual void testStartBeforeEventSubProcess() { var processInstance = runtimeService.StartProcessInstanceByKey("process"); var ProcessInstanceId = processInstance.Id; runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .StartBeforeActivity("eventSubProcess") .Execute(); var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId); Assert.NotNull(updatedTree); Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId); ActivityInstanceAssert.That(updatedTree) .HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId) .BeginScope("eventSubProcess") .Activity("eventSubProcessTask") .EndScope() .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope() .Child("eventSubProcessTask") .Scope() .Done()); completeTasksInOrder("eventSubProcessTask"); AssertProcessEnded(ProcessInstanceId); }
public virtual void testStartBeforeNoneEndEvent() { var processInstance = runtimeService.StartProcessInstanceByKey("oneTaskProcess"); var ProcessInstanceId = processInstance.Id; // when I start before the none end event runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .StartBeforeActivity("theEnd") .Execute(); // then there is no effect var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId); Assert.NotNull(updatedTree); Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId); ActivityInstanceAssert.That(updatedTree) .HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId) .Activity("theTask") .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree("theTask") .Scope() .Done()); completeTasksInOrder("theTask"); AssertProcessEnded(ProcessInstanceId); }
public virtual void testStartBeforeIntermediateCatchEvent() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); string processInstanceId = processInstance.Id; runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("intermediateCatchEvent").execute(); ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("task").activity("intermediateCatchEvent").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task").concurrent().noScope().up().child(null).concurrent().noScope().child("intermediateCatchEvent").scope().done()); ActivityInstance catchEventInstance = getChildInstanceForActivity(updatedTree, "intermediateCatchEvent"); // and there is a timer job Job job = managementService.createJobQuery().singleResult(); assertNotNull(job); assertEquals(catchEventInstance.ExecutionIds[0], job.ExecutionId); completeTasksInOrder("task"); executeAvailableJobs(); assertProcessEnded(processInstanceId); }
public virtual void testTask2AndStartBeforeNonInterruptingBoundaryEventInsideSubProcess() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); string processInstanceId = processInstance.Id; string taskId = taskService.createTaskQuery().singleResult().Id; taskService.complete(taskId); runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("innerBoundaryEvent").execute(); ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).beginScope("subProcess").activity("innerTask2").activity("innerTaskAfterBoundaryEvent").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child(null).scope().child("innerTaskAfterBoundaryEvent").concurrent().noScope().up().child("innerTask2").concurrent().noScope().done()); completeTasksInOrder("innerTask2", "innerTaskAfterBoundaryEvent"); assertProcessEnded(processInstanceId); }
public virtual void testStartBeforeCancelEndEventConcurrent() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); string processInstanceId = processInstance.Id; Task txTask = taskService.createTaskQuery().singleResult(); assertEquals("txTask", txTask.TaskDefinitionKey); // when I start before the cancel end event runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("cancelEnd").execute(); // then the subprocess instance is cancelled ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("afterCancellation").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree("afterCancellation").scope().done()); Task afterCancellationTask = taskService.createTaskQuery().singleResult(); assertNotNull(afterCancellationTask); assertFalse(txTask.Id.Equals(afterCancellationTask.Id)); assertEquals("afterCancellation", afterCancellationTask.TaskDefinitionKey); }
public virtual void testStartBeforNoneStartEvent() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess"); string processInstanceId = processInstance.Id; // when I start before the none start event runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("theStart").execute(); // then there are two instances of "task" ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("theTask").activity("theTask").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child("theTask").concurrent().noScope().up().child("theTask").concurrent().noScope().done()); // and the process can be ended as usual IList <Task> tasks = taskService.createTaskQuery().list(); assertEquals(2, tasks.Count); foreach (Task task in tasks) { taskService.complete(task.Id); } assertProcessEnded(processInstanceId); }
public virtual void testStartBeforeTimerStartEvent() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); string processInstanceId = processInstance.Id; Job startTimerJob = managementService.createJobQuery().singleResult(); assertNotNull(startTimerJob); // when I start before the timer start event runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("theStart").execute(); // then there are two instances of "task" ActivityInstance updatedTree = runtimeService.getActivityInstance(processInstanceId); assertNotNull(updatedTree); assertEquals(processInstanceId, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(processInstance.ProcessDefinitionId).activity("task").activity("task").done()); ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task").concurrent().noScope().up().child("task").concurrent().noScope().done()); // and there is only one timer job Job job = managementService.createJobQuery().singleResult(); assertNotNull(job); assertEquals(startTimerJob.Id, job.Id); completeTasksInOrder("task", "task"); assertProcessEnded(processInstanceId); }
public virtual void testVariableAtScopeExecutionInScopeActivity() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ONE_BOUNDARY_TASK); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapEqualActivities() .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var scopeExecution = executionTreeBeforeMigration.Executions[0]; runtimeService.SetVariableLocal(scopeExecution.Id, "foo", 42); // when testHelper.MigrateProcessInstance(migrationPlan, processInstance); // then var beforeMigration = testHelper.SnapshotBeforeMigration.GetSingleVariable("foo"); Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables() .Count); testHelper.AssertVariableMigratedToExecution(beforeMigration, beforeMigration.ExecutionId); }
public virtual ProcessInstanceSnapshotBuilder executionTree() { ExecutionTree executionTree = ExecutionTree.forExecution(processInstanceId, processEngine); snapshot.ExecutionTree = executionTree; return(this); }
public virtual void testStartBeforeMessageStartEvent() { runtimeService.CorrelateMessage("startMessage"); var processInstance = runtimeService.CreateProcessInstanceQuery() .First(); Assert.NotNull(processInstance); var startEventSubscription = runtimeService.CreateEventSubscriptionQuery() .First(); Assert.NotNull(startEventSubscription); var ProcessInstanceId = processInstance.Id; // when I start before the message start event runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .StartBeforeActivity("theStart") .Execute(); // then there are two instances of "task" var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId); Assert.NotNull(updatedTree); Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId); ActivityInstanceAssert.That(updatedTree) .HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId) .Activity("task") .Activity("task") .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope() .Child("task") .Concurrent() .NoScope() .Up() .Child("task") .Concurrent() .NoScope() .Done()); // and there is only the message start event subscription var subscription = runtimeService.CreateEventSubscriptionQuery() .First(); Assert.NotNull(subscription); Assert.AreEqual(startEventSubscription.Id, subscription.Id); completeTasksInOrder("task", "task"); AssertProcessEnded(ProcessInstanceId); }
public virtual void testVariableAtScopeAndConcurrentExecutionAddParentScope() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewaySubprocessProcess); var migrationPlan = rule.RuntimeService.CreateMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id) .MapActivities("userTask1", "userTask1") .MapActivities("userTask2", "userTask2") .Build(); var processInstance = runtimeService.StartProcessInstanceById(sourceProcessDefinition.Id); var executionTreeBeforeMigration = ExecutionTree.ForExecution(processInstance.Id, rule.ProcessEngine); var userTask1CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0]; var userTask2CCExecutionBefore = executionTreeBeforeMigration.GetLeafExecutions("userTask2")[0]; runtimeService.SetVariableLocal(processInstance.Id, "foo", "processInstanceValue"); runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", "task1Value"); runtimeService.SetVariableLocal(userTask2CCExecutionBefore.Id, "foo", "task2Value"); //var processScopeVariable = runtimeService.CreateVariableInstanceQuery() // //.VariableValueEquals("foo", "processInstanceValue") // .First(); //var task1Variable = runtimeService.CreateVariableInstanceQuery() // //.VariableValueEquals("foo", "task1Value") // .First(); //var task2Variable = runtimeService.CreateVariableInstanceQuery() // //.VariableValueEquals("foo", "task2Value") // .First(); // when testHelper.MigrateProcessInstance(migrationPlan, processInstance); // then the scope variable instance has been overwritten during compaction (conform to prior behavior); // although this is tested here, changing this behavior may be ok in the future Assert.AreEqual(3, testHelper.SnapshotAfterMigration.GetVariables() .Count); //var processScopeVariableAfterMigration = // testHelper.SnapshotAfterMigration.GetVariable(processScopeVariable.Id); //Assert.NotNull(processScopeVariableAfterMigration); //Assert.AreEqual("processInstanceValue", processScopeVariableAfterMigration.Value); //var task1VariableAfterMigration = testHelper.SnapshotAfterMigration.GetVariable(task1Variable.Id); //Assert.NotNull(task1VariableAfterMigration); //Assert.AreEqual("task1Value", task1VariableAfterMigration.Value); //var task2VariableAfterMigration = testHelper.SnapshotAfterMigration.GetVariable(task2Variable.Id); //Assert.NotNull(task2VariableAfterMigration); //Assert.AreEqual("task2Value", task2VariableAfterMigration.Value); }