public virtual void testVariableAtScopeAndConcurrentExecutionRemoveParentScope() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewaySubprocessProcess); var targetProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess); 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]; var subProcessExecution = userTask1CCExecutionBefore.Parent; runtimeService.SetVariableLocal(subProcessExecution.Id, "foo", "subProcessValue"); runtimeService.SetVariableLocal(userTask1CCExecutionBefore.Id, "foo", "task1Value"); runtimeService.SetVariableLocal(userTask2CCExecutionBefore.Id, "foo", "task2Value"); //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 var variables = testHelper.SnapshotAfterMigration.GetVariables(); Assert.AreEqual(2, variables.Count); //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); }
public virtual void testStartBeforeNonInterruptingEventSubProcessInsideSubProcessTask2ShouldStay() { var processInstance = runtimeService.StartProcessInstanceByKey("process"); var ProcessInstanceId = processInstance.Id; var taskId = taskService.CreateTaskQuery() .First() .Id; taskService.Complete(taskId); 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("subProcess") .Activity("task2") .BeginScope("eventSubProcess") .Activity("eventSubProcessTask") .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope() .Child(null) .Scope() .Child("task2") .Concurrent() .NoScope() .Up() .Child(null) .Concurrent() .NoScope() .Child("eventSubProcessTask") .Scope() .Done()); completeTasksInOrder("task2", "eventSubProcessTask"); AssertProcessEnded(ProcessInstanceId); }
public virtual void testNonInterruptingEventInCombinationWithUserTaskInsideSubProcess() { // given string ProcessInstanceId = runtimeService.StartProcessInstanceByKey("process").Id; // when (1) runtimeService.CorrelateMessage("firstMessage"); // then (1) Assert.AreEqual(2, taskService.CreateTaskQuery().Count()); ITask task1 = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "task1").First(); Assert.NotNull(task1); ITask innerTask = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "innerTask").First(); Assert.NotNull(innerTask); ExecutionTree executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope().Child(null).Scope().Child("task1").NoScope().Concurrent().Up().Child(null).NoScope().Concurrent().Child("innerTask").Scope().Done()); // when (2) taskService.Complete(innerTask.Id); // then (2) Assert.AreEqual(2, taskService.CreateTaskQuery().Count()); task1 = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "task1").First(); Assert.NotNull(task1); ITask task2 = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "task2").First(); Assert.NotNull(task2); Assert.AreEqual(0, runtimeService.CreateEventSubscriptionQuery().Count()); executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope().Child(null).Scope().Child("task1").NoScope().Concurrent().Up().Child("task2").NoScope().Concurrent().Done()); taskService.Complete(task1.Id); taskService.Complete(task2.Id); AssertProcessEnded(ProcessInstanceId); }
public virtual void testAddScopeWithInputMappingAndVariableOnConcurrentExecutions() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess); var targetProcessDefinition = testHelper.DeployAndGetDefinition( ModifiableBpmnModelInstance.Modify(ProcessModels.ParallelGatewaySubprocessProcess) //.ActivityBuilder("subProcess") //.CamundaInputParameter("foo", "inputOutputValue") //.Done() ); 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(userTask1CCExecutionBefore.Id, "foo", "customValue"); runtimeService.SetVariableLocal(userTask2CCExecutionBefore.Id, "foo", "customValue"); // 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 var variables = testHelper.SnapshotAfterMigration.GetVariables(); Assert.AreEqual(2, variables.Count); foreach (var variable in variables) { Assert.AreEqual("customValue", variable.Value); } var subProcessExecution = testHelper.SnapshotAfterMigration.ExecutionTree.GetLeafExecutions("userTask2")[0].Parent; Assert.NotNull(testHelper.SnapshotAfterMigration.GetSingleVariable(subProcessExecution.Id, "foo")); }
public virtual void testVariableAtConcurrentExecutionAddParentScopeBecomeNonConcurrent() { // given var sourceProcessDefinition = testHelper.DeployAndGetDefinition(ProcessModels.ParallelGatewayProcess); var targetProcessDefinition = testHelper.DeployAndGetDefinition( ModifiableBpmnModelInstance.Modify(ProcessModels.ParallelTaskAndSubprocessProcess) //.ActivityBuilder("subProcess") //.CamundaInputParameter("foo", "subProcessValue") //.Done() ); 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 task1CcExecution = executionTreeBeforeMigration.GetLeafExecutions("userTask1")[0]; var 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.AreEqual(2, testHelper.SnapshotAfterMigration.GetVariables() .Count); IList <string> values = new List <string>(); foreach (var variable in testHelper.SnapshotAfterMigration.GetVariables()) { values.Add((string)variable.Value); } Assert.True(values.Contains("task1Value")); Assert.True(values.Contains("task2Value")); }
public virtual void testMultipleNonInterruptingInEmbeddedSubprocess() { IProcessInstance processInstance = runtimeService.StartProcessInstanceByKey("process"); // the process instance must have a message event subscription: IExecution subProcess = runtimeService.CreateExecutionQuery() /*.MessageEventSubscriptionName("newMessage")*/.First(); Assert.NotNull(subProcess); Assert.AreEqual(1, CreateEventSubscriptionQuery().Count()); ITask subProcessTask = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "subProcessTask").First(); Assert.NotNull(subProcessTask); // start event sub process multiple times for (int i = 1; i < 3; i++) { runtimeService.MessageEventReceived("newMessage", subProcess.Id); // check that now i event sub process tasks exist IList <ITask> eventSubProcessTasks = taskService.CreateTaskQuery(c => c.TaskDefinitionKey == "eventSubProcessTask").ToList(); Assert.AreEqual(i, eventSubProcessTasks.Count); } ExecutionTree executionTree = ExecutionTree.ForExecution(processInstance.Id, ProcessEngine); // check that the parent execution of the event sub process task execution is the event // sub process execution ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope().Child(null) .Scope().Child("subProcessTask").Concurrent().NoScope().Up().Child(null).Concurrent().NoScope().Child("eventSubProcessTask") .Scope().Up().Up().Child(null).Concurrent().NoScope().Child("eventSubProcessTask").Scope().Done()); // complete sub process task taskService.Complete(subProcessTask.Id); // after complete the sub process task all task should be deleted because of the terminating end event Assert.AreEqual(0, taskService.CreateTaskQuery().Count()); // and the process instance should be ended Assert.AreEqual(0, runtimeService.CreateProcessInstanceQuery().Count()); }
public virtual void testTask1AndStartBeforeTaskAfterNonInterruptingBoundaryEventInsideSubProcess() { var processInstance = runtimeService.StartProcessInstanceByKey("process"); var ProcessInstanceId = processInstance.Id; runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .StartBeforeActivity("innerTaskAfterBoundaryEvent") .Execute(); var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId); Assert.NotNull(updatedTree); Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId); ActivityInstanceAssert.That(updatedTree) .HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId) .BeginScope("subProcess") .Activity("innerTask1") .Activity("innerTaskAfterBoundaryEvent") .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope() .Child(null) .Scope() .Child("innerTaskAfterBoundaryEvent") .Concurrent() .NoScope() .Up() .Child(null) .Concurrent() .NoScope() .Child("innerTask1") .Scope() .Done()); completeTasksInOrder("innerTask1", "innerTaskAfterBoundaryEvent", "innerTask2"); AssertProcessEnded(ProcessInstanceId); }
public virtual void testStartBeforeCancelEndEventConcurrent() { var processInstance = runtimeService.StartProcessInstanceByKey("process"); var ProcessInstanceId = processInstance.Id; var txTask = taskService.CreateTaskQuery() .First(); Assert.AreEqual("txTask", txTask.TaskDefinitionKey); // when I start before the cancel end event runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .StartBeforeActivity("cancelEnd") .Execute(); // then the subprocess instance is cancelled var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId); Assert.NotNull(updatedTree); Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId); ActivityInstanceAssert.That(updatedTree) .HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId) .Activity("afterCancellation") .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree("afterCancellation") .Scope() .Done()); var afterCancellationTask = taskService.CreateTaskQuery() .First(); Assert.NotNull(afterCancellationTask); Assert.IsFalse(txTask.Id.Equals(afterCancellationTask.Id)); Assert.AreEqual("afterCancellation", afterCancellationTask.TaskDefinitionKey); }
public virtual void testNonInterruptingWithParallelForkInsideEmbeddedSubProcess() { IProcessInstance processInstance = runtimeService.StartProcessInstanceByKey("process"); runtimeService.MessageEventReceived("newMessage", runtimeService.CreateEventSubscriptionQuery().First().ExecutionId); ExecutionTree executionTree = ExecutionTree.ForExecution(processInstance.Id, ProcessEngine); ExecutionAssert.That(executionTree).Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope().Child(null).Scope().Child("firstUserTask").Concurrent().NoScope().Up().Child("secondUserTask") .Concurrent().NoScope().Up().Child(null).Concurrent().NoScope().Child("eventSubProcessTask").Done()); IList <ITask> tasks = taskService.CreateTaskQuery().ToList(); foreach (ITask task in tasks) { taskService.Complete(task.Id); } AssertProcessEnded(processInstance.Id); }
public virtual void testVariableAtScopeExecutionBecomeNonScope() { // 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.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, processInstance.Id); // and the variable is concurrent local, i.E. expands on tree expansion runtimeService.CreateProcessInstanceModification(processInstance.Id) .StartBeforeActivity("userTask") .Execute(); var variableAfterExpansion = runtimeService.CreateVariableInstanceQuery() .First(); Assert.NotNull(variableAfterExpansion); Assert.AreNotSame(processInstance.Id, variableAfterExpansion.ExecutionId); }
public virtual void testVariableAtConcurrentExecutionInScopeActivityAddParentScope() { // 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 var beforeMigration = testHelper.SnapshotBeforeMigration.GetSingleVariable("foo"); var userTask1CCExecutionAfter = testHelper.SnapshotAfterMigration.ExecutionTree.GetLeafExecutions("userTask1")[0].Parent; Assert.AreEqual(1, testHelper.SnapshotAfterMigration.GetVariables() .Count); var subProcessInstance = testHelper.GetSingleActivityInstanceAfterMigration("subProcess"); // 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, subProcessInstance.Id); }
public virtual void testStartBeforeTaskInsideEventSubProcessAndCancelTaskOutsideEventSubProcess() { var processInstance = runtimeService.StartProcessInstanceByKey("process"); var ProcessInstanceId = processInstance.Id; var tree = runtimeService.GetActivityInstance(processInstance.Id); runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .CancelActivityInstance(getInstanceIdForActivity(tree, "task1")) .StartBeforeActivity("eventSubProcessTask") .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 testStartBeforeCancelEndEvent() { var processInstance = runtimeService.StartProcessInstanceByKey("process"); var ProcessInstanceId = processInstance.Id; // complete the transaction subprocess once var txTask = taskService.CreateTaskQuery() .First(); Assert.AreEqual("txTask", txTask.TaskDefinitionKey); taskService.Complete(txTask.Id, ESS.FW.Bpm.Engine.Variable.Variables.CreateVariables() .PutValue("success", true)); var afterSuccessTask = taskService.CreateTaskQuery() .First(); Assert.AreEqual("afterSuccess", afterSuccessTask.TaskDefinitionKey); // when I start before the cancel end event runtimeService.CreateProcessInstanceModification(ProcessInstanceId) .StartBeforeActivity("cancelEnd") .Execute(); // then a new subprocess instance is created and immediately cancelled var updatedTree = runtimeService.GetActivityInstance(ProcessInstanceId); Assert.NotNull(updatedTree); Assert.AreEqual(ProcessInstanceId, updatedTree.ProcessInstanceId); ActivityInstanceAssert.That(updatedTree) .HasStructure(ActivityInstanceAssert.DescribeActivityInstanceTree(processInstance.ProcessDefinitionId) .Activity("afterCancellation") .Activity("afterSuccess") .Done()); var executionTree = ExecutionTree.ForExecution(ProcessInstanceId, ProcessEngine); ExecutionAssert.That(executionTree) .Matches(ExecutionAssert.DescribeExecutionTree(null) .Scope() .Child("afterCancellation") .Concurrent() .NoScope() .Up() .Child("afterSuccess") .Concurrent() .NoScope() .Up() .Child("tx") .Scope() .EventScope() .Done()); // the compensation for the completed tx has not been triggered Assert.AreEqual(0, taskService.CreateTaskQuery(c => c.TaskDefinitionKeyWithoutCascade == "undoTxTask") .Count()); // complete the process var afterCancellationTask = taskService.CreateTaskQuery(c => c.TaskDefinitionKeyWithoutCascade == "afterCancellation") .First(); Assert.NotNull(afterCancellationTask); taskService.Complete(afterCancellationTask.Id); taskService.Complete(afterSuccessTask.Id); AssertProcessEnded(ProcessInstanceId); }