//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCompletionWithSuspension() public virtual void testCompletionWithSuspension() { BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().userTask().endEvent().done(); ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance); ProcessInstance processInstance = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); HistoricProcessInstance entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); //suspend processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessInstanceId(processInstance.Id).suspend(); entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED)); //activate processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessInstanceId(processInstance.Id).activate(); entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); //complete task processEngineRule.TaskService.complete(processEngineRule.TaskService.createTaskQuery().active().singleResult().Id); //make sure happy path ended entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_COMPLETED)); }
public static HistoricProcessInstanceDto fromHistoricProcessInstance(HistoricProcessInstance historicProcessInstance) { HistoricProcessInstanceDto dto = new HistoricProcessInstanceDto(); dto.id = historicProcessInstance.Id; dto.businessKey = historicProcessInstance.BusinessKey; dto.processDefinitionId = historicProcessInstance.ProcessDefinitionId; dto.processDefinitionKey = historicProcessInstance.ProcessDefinitionKey; dto.processDefinitionName = historicProcessInstance.ProcessDefinitionName; dto.processDefinitionVersion = historicProcessInstance.ProcessDefinitionVersion; dto.startTime = historicProcessInstance.StartTime; dto.endTime = historicProcessInstance.EndTime; dto.removalTime = historicProcessInstance.RemovalTime; dto.durationInMillis = historicProcessInstance.DurationInMillis; dto.startUserId = historicProcessInstance.StartUserId; dto.startActivityId = historicProcessInstance.StartActivityId; dto.deleteReason = historicProcessInstance.DeleteReason; dto.rootProcessInstanceId = historicProcessInstance.RootProcessInstanceId; dto.superProcessInstanceId = historicProcessInstance.SuperProcessInstanceId; dto.superCaseInstanceId = historicProcessInstance.SuperCaseInstanceId; dto.caseInstanceId = historicProcessInstance.CaseInstanceId; dto.tenantId = historicProcessInstance.TenantId; dto.state = historicProcessInstance.State; return(dto); }
protected internal virtual void ensureSameProcessDefinition(HistoricProcessInstance instance, string processDefinitionId) { if (!processDefinitionId.Equals(instance.ProcessDefinitionId)) { throw LOG.processDefinitionOfHistoricInstanceDoesNotMatchTheGivenOne(instance, processDefinitionId); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testSuspensionByProcessDefinition() public virtual void testSuspensionByProcessDefinition() { BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().userTask().endEvent().done(); ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance); ProcessInstance processInstance1 = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); ProcessInstance processInstance2 = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); //suspend all processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionId(processDefinition.Id).suspend(); HistoricProcessInstance hpi1 = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().processInstanceId(processInstance1.Id).singleResult(); HistoricProcessInstance hpi2 = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().processInstanceId(processInstance2.Id).singleResult(); assertThat(hpi1.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED)); assertThat(hpi2.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_SUSPENDED)); assertEquals(2, processEngineRule.HistoryService.createHistoricProcessInstanceQuery().suspended().count()); //activate all processEngineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(processDefinition.Key).activate(); hpi1 = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().processInstanceId(processInstance1.Id).singleResult(); hpi2 = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().processInstanceId(processInstance2.Id).singleResult(); assertThat(hpi1.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); assertThat(hpi2.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); assertEquals(2, processEngineRule.HistoryService.createHistoricProcessInstanceQuery().active().count()); }
public virtual void testHistoricProcessInstanceForSingleActivityInstantiation() { // when ProcessInstance instance = runtimeService.createProcessInstanceByKey("exclusiveGateway").startBeforeActivity("task1").execute(); // then HistoricProcessInstance historicInstance = historyService.createHistoricProcessInstanceQuery().singleResult(); assertNotNull(historicInstance); assertEquals(instance.Id, historicInstance.Id); assertNotNull(historicInstance.StartTime); assertNull(historicInstance.EndTime); // should be the first activity started assertEquals("task1", historicInstance.StartActivityId); HistoricActivityInstance historicActivityInstance = historyService.createHistoricActivityInstanceQuery().singleResult(); assertNotNull(historicActivityInstance); assertEquals("task1", historicActivityInstance.ActivityId); assertNotNull(historicActivityInstance.Id); assertFalse(instance.Id.Equals(historicActivityInstance.Id)); assertNotNull(historicActivityInstance.StartTime); assertNull(historicActivityInstance.EndTime); }
protected internal virtual void ensureHistoricProcessInstanceNotActive(HistoricProcessInstance instance) { if (instance.EndTime == null) { throw LOG.historicProcessInstanceActive(instance); } }
protected internal virtual void logActivityResults(PerfTestPass pass, PerfTestRun run, HistoryService historyService) { string processInstanceId = run.getVariable(PerfTestConstants.PROCESS_INSTANCE_ID); IList <ActivityPerfTestResult> activityResults = new List <ActivityPerfTestResult>(); HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult(); DateTime startTime = processInstance.StartTime; IList <HistoricActivityInstance> activityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).orderByHistoricActivityInstanceStartTime().asc().list(); foreach (HistoricActivityInstance activityInstance in activityInstances) { if (watchAllActivities || activityIds.Contains(activityInstance.ActivityId)) { ActivityPerfTestResult result = new ActivityPerfTestResult(activityInstance); if (activityInstance.ActivityType.Equals("startEvent")) { result.StartTime = startTime; } activityResults.Add(result); } } pass.logActivityResult(processInstanceId, activityResults); }
public virtual void assertReportResults(IList <DurationReportResult> actual) { assertEquals("Report size", periodToProcessInstancesMap.Count, actual.Count); foreach (DurationReportResult reportResult in actual) { assertEquals("Period unit", periodUnit, reportResult.PeriodUnit); int period = reportResult.Period; ISet <string> processInstancesInPeriod = periodToProcessInstancesMap[period]; assertNotNull("Unexpected report for period " + period, processInstancesInPeriod); IList <HistoricProcessInstance> historicProcessInstances = outerInstance.historyService.createHistoricProcessInstanceQuery().processInstanceIds(processInstancesInPeriod).finished().list(); long max = 0; long min = 0; long sum = 0; for (int i = 0; i < historicProcessInstances.Count; i++) { HistoricProcessInstance historicProcessInstance = historicProcessInstances[i]; long?duration = historicProcessInstance.DurationInMillis; sum = sum + duration; max = i > 0 ? Math.Max(max, duration) : duration.Value; min = i > 0 ? Math.Min(min, duration) : duration.Value; } long avg = sum / historicProcessInstances.Count; assertEquals("maximum", max, reportResult.Maximum); assertEquals("minimum", min, reportResult.Minimum); assertEquals("average", avg, reportResult.Average, 1); } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: @Override public Void execute(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext) public override Void execute(CommandContext commandContext) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.Collection<String> processInstanceIds = collectProcessInstanceIds(); ICollection <string> processInstanceIds = collectProcessInstanceIds(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.List<AbstractProcessInstanceModificationCommand> instructions = builder.getInstructions(); IList <AbstractProcessInstanceModificationCommand> instructions = builder.Instructions; ensureNotEmpty(typeof(BadUserRequestException), "Restart instructions cannot be empty", "instructions", instructions); ensureNotEmpty(typeof(BadUserRequestException), "Process instance ids cannot be empty", "Process instance ids", processInstanceIds); ensureNotContainsNull(typeof(BadUserRequestException), "Process instance ids cannot be null", "Process instance ids", processInstanceIds); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.camunda.bpm.engine.impl.persistence.entity.ProcessDefinitionEntity processDefinition = getProcessDefinition(commandContext, builder.getProcessDefinitionId()); ProcessDefinitionEntity processDefinition = getProcessDefinition(commandContext, builder.ProcessDefinitionId); ensureNotNull("Process definition cannot be found", "processDefinition", processDefinition); checkAuthorization(commandContext, processDefinition); if (writeUserOperationLog) { writeUserOperationLog(commandContext, processDefinition, processInstanceIds.Count, false); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String processDefinitionId = builder.getProcessDefinitionId(); string processDefinitionId = builder.ProcessDefinitionId; ThreadStart runnable = () => { foreach (string processInstanceId in processInstanceIds) { HistoricProcessInstance historicProcessInstance = getHistoricProcessInstance(commandContext, processInstanceId); ensureNotNull(typeof(BadUserRequestException), "Historic process instance cannot be found", "historicProcessInstanceId", historicProcessInstance); ensureHistoricProcessInstanceNotActive(historicProcessInstance); ensureSameProcessDefinition(historicProcessInstance, processDefinitionId); ProcessInstantiationBuilderImpl instantiationBuilder = getProcessInstantiationBuilder(commandExecutor, processDefinitionId); applyProperties(instantiationBuilder, processDefinition, historicProcessInstance); ProcessInstanceModificationBuilderImpl modificationBuilder = instantiationBuilder.ModificationBuilder; modificationBuilder.ModificationOperations = instructions; VariableMap variables = collectVariables(commandContext, historicProcessInstance); instantiationBuilder.Variables = variables; instantiationBuilder.execute(builder.SkipCustomListeners, builder.SkipIoMappings); } }; ProcessApplicationContextUtil.doContextSwitch(runnable, processDefinition); return(null); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCompletedOnEndEvent() public virtual void testCompletedOnEndEvent() { BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().endEvent().done(); ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance); processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); HistoricProcessInstance entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_COMPLETED)); }
private void assertThatInstanceHasAllImportantInformation(HistoricProcessInstance historicProcessInstance) { assertThat(historicProcessInstance, notNullValue()); assertThat(historicProcessInstance.Id, notNullValue()); assertThat(historicProcessInstance.ProcessDefinitionKey, @is("process")); assertThat(historicProcessInstance.ProcessDefinitionVersion, notNullValue()); assertThat(historicProcessInstance.ProcessDefinitionId, notNullValue()); assertThat(historicProcessInstance.StartTime, notNullValue()); assertThat(historicProcessInstance.EndTime, nullValue()); }
public virtual void testQueryHistoricProcessWithParallelGateway() { //given an already finished process instance with parallel gateway and two user tasks HistoricProcessInstance historicProcessInstance = rule.historicProcessInstance(); //when query history HistoricTaskInstanceQuery historicTaskQuery = rule.HistoryService.createHistoricTaskInstanceQuery().processInstanceId(historicProcessInstance.Id); //then two historic user tasks are returned Assert.assertEquals(2, historicTaskQuery.count()); }
public virtual HistoricProcessInstance historicProcessInstance() { HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceBusinessKey(BuisnessKey).singleResult(); if (historicProcessInstance == null) { throw new Exception("There is no historic process instance for scenario " + BuisnessKey); } return(historicProcessInstance); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testTerminatedInternalWithGateway() public virtual void testTerminatedInternalWithGateway() { BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().parallelGateway().endEvent().moveToLastGateway().endEvent(TERMINATION).done(); initEndEvent(instance, TERMINATION); ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance); processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); HistoricProcessInstance entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_COMPLETED)); }
private void createHistoricProcessInstanceMock() { IList <HistoricProcessInstance> processes = new List <HistoricProcessInstance>(); HistoricProcessInstance mockInstance = MockProvider.createMockHistoricProcessInstance(); processes.Add(mockInstance); HistoricProcessInstanceQuery mockHistoricProcessInstanceQuery = mock(typeof(HistoricProcessInstanceQuery)); when(mockHistoricProcessInstanceQuery.list()).thenReturn(processes); when(mockHistoryService.createHistoricProcessInstanceQuery()).thenReturn(mockHistoricProcessInstanceQuery); }
public virtual void testHistoricActivityInstancesForSubprocess() { // when ProcessInstance instance = runtimeService.createProcessInstanceByKey("subprocess").startBeforeActivity("innerTask").startBeforeActivity("theSubProcessStart").execute(); // then HistoricProcessInstance historicInstance = historyService.createHistoricProcessInstanceQuery().singleResult(); assertNotNull(historicInstance); assertEquals(instance.Id, historicInstance.Id); assertNotNull(historicInstance.StartTime); assertNull(historicInstance.EndTime); // should be the first activity started assertEquals("innerTask", historicInstance.StartActivityId); // subprocess, subprocess start event, two innerTasks assertEquals(4, historyService.createHistoricActivityInstanceQuery().count()); HistoricActivityInstance subProcessInstance = historyService.createHistoricActivityInstanceQuery().activityId("subProcess").singleResult(); assertNotNull(subProcessInstance); assertEquals("subProcess", subProcessInstance.ActivityId); assertNotNull(subProcessInstance.Id); assertFalse(instance.Id.Equals(subProcessInstance.Id)); assertNotNull(subProcessInstance.StartTime); assertNull(subProcessInstance.EndTime); HistoricActivityInstance startEventInstance = historyService.createHistoricActivityInstanceQuery().activityId("theSubProcessStart").singleResult(); assertNotNull(startEventInstance); assertEquals("theSubProcessStart", startEventInstance.ActivityId); assertNotNull(startEventInstance.Id); assertFalse(instance.Id.Equals(startEventInstance.Id)); assertNotNull(startEventInstance.StartTime); assertNotNull(startEventInstance.EndTime); IList <HistoricActivityInstance> innerTaskInstances = historyService.createHistoricActivityInstanceQuery().activityId("innerTask").list(); assertEquals(2, innerTaskInstances.Count); foreach (HistoricActivityInstance innerTaskInstance in innerTaskInstances) { assertNotNull(innerTaskInstance); assertEquals("innerTask", innerTaskInstance.ActivityId); assertNotNull(innerTaskInstance.Id); assertFalse(instance.Id.Equals(innerTaskInstance.Id)); assertNotNull(innerTaskInstance.StartTime); assertNull(innerTaskInstance.EndTime); } }
public virtual void testHistoricProcessInstanceForSynchronousCompletion() { // when the process instance ends immediately ProcessInstance instance = runtimeService.createProcessInstanceByKey("exclusiveGateway").startAfterActivity("task1").execute(); // then HistoricProcessInstance historicInstance = historyService.createHistoricProcessInstanceQuery().singleResult(); assertNotNull(historicInstance); assertEquals(instance.Id, historicInstance.Id); assertNotNull(historicInstance.StartTime); assertNotNull(historicInstance.EndTime); assertEquals("join", historicInstance.StartActivityId); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCancellationState() public virtual void testCancellationState() { BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().userTask().endEvent().done(); ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance); ProcessInstance processInstance = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); HistoricProcessInstance entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); //same call as in ProcessInstanceResourceImpl processEngineRule.RuntimeService.deleteProcessInstance(processInstance.Id, REASON, false, true); entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_EXTERNALLY_TERMINATED)); assertEquals(1, processEngineRule.HistoryService.createHistoricProcessInstanceQuery().externallyTerminated().count()); }
public virtual void deployAndCompleteProcesses() { ProcessDefinition sourceDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS); processInstance = engineRule.RuntimeService.startProcessInstanceById(sourceDefinition.Id); processInstance2 = engineRule.RuntimeService.startProcessInstanceById(sourceDefinition.Id); IList <string> processInstanceIds = Arrays.asList(new string[] { processInstance.Id, processInstance2.Id }); runtimeService.deleteProcessInstances(processInstanceIds, null, false, false); historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstance.Id).singleResult(); historicProcessInstance2 = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstance2.Id).singleResult(); }
public virtual void test() { // given processEngineRule.RuntimeService.startProcessInstanceByKey("Process_1"); string jobId = processEngineRule.ManagementService.createJobQuery().timers().executable().singleResult().Id; // when processEngineRule.ManagementService.executeJob(jobId); HistoricProcessInstance historicProcessInstance = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().singleResult(); // then assertThat(historicProcessInstance.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); assertThat(historicProcessInstance.EndTime, nullValue()); }
public virtual void testWithCallActivity() { processEngineRule.RuntimeService.startProcessInstanceByKey("Main_Process"); assertThat(processEngineRule.RuntimeService.createProcessInstanceQuery().active().list().size(), @is(0)); HistoricProcessInstance entity1 = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().processDefinitionKey("Main_Process").singleResult(); HistoricProcessInstance entity2 = processEngineRule.HistoryService.createHistoricProcessInstanceQuery().processDefinitionKey("Sub_Process").singleResult(); assertThat(entity1, @is(notNullValue())); assertThat(entity2, @is(notNullValue())); assertThat(entity1.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_COMPLETED)); assertEquals(1, processEngineRule.HistoryService.createHistoricProcessInstanceQuery().completed().count()); assertThat(entity2.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_INTERNALLY_TERMINATED)); assertEquals(1, processEngineRule.HistoryService.createHistoricProcessInstanceQuery().internallyTerminated().count()); }
public virtual void testCancelTaskShouldCancelProcessInstance() { // given string processInstanceId = runtimeService.startProcessInstanceByKey("oneTaskProcess").Id; // when runtimeService.createProcessInstanceModification(processInstanceId).cancelAllForActivity("theTask").execute(true, false); // then HistoricProcessInstance instance = historyService.createHistoricProcessInstanceQuery().singleResult(); assertNotNull(instance); assertEquals(processInstanceId, instance.Id); assertNotNull(instance.EndTime); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testGetSingleInstance() public virtual void testGetSingleInstance() { HistoricProcessInstance mockInstance = MockProvider.createMockHistoricProcessInstance(); HistoricProcessInstanceQuery sampleInstanceQuery = mock(typeof(HistoricProcessInstanceQuery)); when(historyServiceMock.createHistoricProcessInstanceQuery()).thenReturn(sampleInstanceQuery); when(sampleInstanceQuery.processInstanceId(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID)).thenReturn(sampleInstanceQuery); when(sampleInstanceQuery.singleResult()).thenReturn(mockInstance); Response response = given().pathParam("id", MockProvider.EXAMPLE_PROCESS_INSTANCE_ID).then().expect().statusCode(Status.OK.StatusCode).when().get(HISTORIC_SINGLE_PROCESS_INSTANCE_URL); string content = response.asString(); string returnedProcessInstanceId = from(content).getString("id"); string returnedProcessInstanceBusinessKey = from(content).getString("businessKey"); string returnedProcessDefinitionId = from(content).getString("processDefinitionId"); string returnedProcessDefinitionKey = from(content).getString("processDefinitionKey"); string returnedStartTime = from(content).getString("startTime"); string returnedEndTime = from(content).getString("endTime"); long returnedDurationInMillis = from(content).getLong("durationInMillis"); string returnedStartUserId = from(content).getString("startUserId"); string returnedStartActivityId = from(content).getString("startActivityId"); string returnedDeleteReason = from(content).getString(DELETE_REASON); string returnedSuperProcessInstanceId = from(content).getString("superProcessInstanceId"); string returnedSuperCaseInstanceId = from(content).getString("superCaseInstanceId"); string returnedCaseInstanceId = from(content).getString("caseInstanceId"); string returnedTenantId = from(content).getString("tenantId"); string returnedState = from(content).getString("state"); Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedProcessInstanceId); Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_BUSINESS_KEY, returnedProcessInstanceBusinessKey); Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID, returnedProcessDefinitionId); Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY, returnedProcessDefinitionKey); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_START_TIME, returnedStartTime); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_END_TIME, returnedEndTime); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_DURATION_MILLIS, returnedDurationInMillis); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_START_USER_ID, returnedStartUserId); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_START_ACTIVITY_ID, returnedStartActivityId); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_DELETE_REASON, returnedDeleteReason); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_SUPER_PROCESS_INSTANCE_ID, returnedSuperProcessInstanceId); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_SUPER_CASE_INSTANCE_ID, returnedSuperCaseInstanceId); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_CASE_INSTANCE_ID, returnedCaseInstanceId); Assert.assertEquals(MockProvider.EXAMPLE_TENANT_ID, returnedTenantId); Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_PROCESS_INSTANCE_STATE, returnedState); }
public virtual void testSimpleQueryWithReadHistoryPermissionOnProcessDefinition() { // given string processInstanceId = startProcessInstanceByKey(PROCESS_KEY).Id; createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY); // when HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery(); // then verifyQueryResults(query, 1); HistoricProcessInstance instance = query.singleResult(); assertNotNull(instance); assertEquals(processInstanceId, instance.Id); }
public virtual void testTerminateInSubProcessConcurrentShouldNotEndProcessInstanceInHistory() { // when process instance is started and terminate end event in subprocess executed ProcessInstance pi = runtimeService.startProcessInstanceByKey("terminateEndEventExample"); // then the historic process instance should not appear ended assertProcessNotEnded(pi.Id); if (processEngineConfiguration.HistoryLevel.Id > ProcessEngineConfigurationImpl.HISTORYLEVEL_NONE) { HistoricProcessInstance hpi = historyService.createHistoricProcessInstanceQuery().singleResult(); assertNotNull(hpi); assertNull(hpi.EndTime); assertNull(hpi.DurationInMillis); assertNull(hpi.DeleteReason); } }
public virtual void testHistoricProcessInstanceAsyncStartEvent() { // when ProcessInstance instance = runtimeService.createProcessInstanceByKey("exclusiveGateway").startBeforeActivity("task2").setVariable("aVar", "aValue").execute(); // then HistoricProcessInstance historicInstance = historyService.createHistoricProcessInstanceQuery().singleResult(); assertNotNull(historicInstance); assertEquals(instance.Id, historicInstance.Id); assertNotNull(historicInstance.StartTime); assertNull(historicInstance.EndTime); // should be the first activity started assertEquals("task2", historicInstance.StartActivityId); // task2 wasn't entered yet assertEquals(0, historyService.createHistoricActivityInstanceQuery().count()); // history events for variables exist already ActivityInstance activityInstance = runtimeService.getActivityInstance(instance.Id); HistoricVariableInstance historicVariable = historyService.createHistoricVariableInstanceQuery().variableName("aVar").singleResult(); assertNotNull(historicVariable); assertEquals(instance.Id, historicVariable.ProcessInstanceId); assertEquals(activityInstance.Id, historicVariable.ActivityInstanceId); assertEquals("aVar", historicVariable.Name); assertEquals("aValue", historicVariable.Value); HistoricDetail historicDetail = historyService.createHistoricDetailQuery().variableInstanceId(historicVariable.Id).singleResult(); assertEquals(instance.Id, historicDetail.ProcessInstanceId); assertNotNull(historicDetail); // TODO: fix if this is not ok due to CAM-3886 assertNull(historicDetail.ActivityInstanceId); assertTrue(historicDetail is HistoricVariableUpdate); assertEquals("aVar", ((HistoricVariableUpdate)historicDetail).VariableName); assertEquals("aValue", ((HistoricVariableUpdate)historicDetail).Value); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Deployment public void testSetProcessDefinitionVersion() public virtual void testSetProcessDefinitionVersion() { // start process instance ProcessInstance pi = runtimeService.startProcessInstanceByKey("receiveTask"); // check that receive task has been reached Execution execution = runtimeService.createExecutionQuery().processInstanceId(pi.Id).activityId("waitState1").singleResult(); assertNotNull(execution); // deploy new version of the process definition org.camunda.bpm.engine.repository.Deployment deployment = repositoryService.createDeployment().addClasspathResource(TEST_PROCESS).deploy(); assertEquals(2, repositoryService.createProcessDefinitionQuery().count()); // migrate process instance to new process definition version CommandExecutor commandExecutor = processEngineConfiguration.CommandExecutorTxRequired; commandExecutor.execute(new SetProcessDefinitionVersionCmd(pi.Id, 2)); // signal process instance runtimeService.signal(execution.Id); // check that the instance now uses the new process definition version ProcessDefinition newProcessDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionVersion(2).singleResult(); pi = runtimeService.createProcessInstanceQuery().processInstanceId(pi.Id).singleResult(); assertEquals(newProcessDefinition.Id, pi.ProcessDefinitionId); // check history if (processEngineConfiguration.HistoryLevel.Id > ProcessEngineConfigurationImpl.HISTORYLEVEL_NONE) { HistoricProcessInstance historicPI = historyService.createHistoricProcessInstanceQuery().processInstanceId(pi.Id).singleResult(); // assertEquals(newProcessDefinition.getId(), historicPI.getProcessDefinitionId()); } // undeploy "manually" deployed process definition repositoryService.deleteDeployment(deployment.Id, true); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testSateOfScriptTaskProcessWithTransactionCommitAndException() public virtual void testSateOfScriptTaskProcessWithTransactionCommitAndException() { BpmnModelInstance instance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().camundaAsyncAfter().scriptTask().scriptText("throw new RuntimeException()").scriptFormat("groovy").endEvent().done(); ProcessDefinition processDefinition = processEngineTestRule.deployAndGetDefinition(instance); try { ProcessInstance pi = processEngineRule.RuntimeService.startProcessInstanceById(processDefinition.Id); processEngineRule.ManagementService.executeJob(processEngineRule.ManagementService.createJobQuery().executable().singleResult().Id); fail("exception expected"); } catch (Exception) { //expected } assertThat(processEngineRule.RuntimeService.createProcessInstanceQuery().active().list().size(), @is(1)); HistoricProcessInstance entity = getHistoricProcessInstanceWithAssertion(processDefinition); assertThat(entity.State, @is(org.camunda.bpm.engine.history.HistoricProcessInstance_Fields.STATE_ACTIVE)); assertEquals(1, processEngineRule.HistoryService.createHistoricProcessInstanceQuery().active().count()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSetRemovalTimeForRootProcessInstanceOnly() public virtual void shouldSetRemovalTimeForRootProcessInstanceOnly() { // given HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().processInstanceBusinessKey("rootProcessInstance"); HistoricProcessInstance historicRootProcessInstance = query.singleResult(); HistoricProcessInstance historicChildProcessInstance = historyService.createHistoricProcessInstanceQuery().superProcessInstanceId(historicRootProcessInstance.Id).singleResult(); // assume assertThat(historicRootProcessInstance.RemovalTime, nullValue()); assertThat(historicChildProcessInstance.RemovalTime, nullValue()); // when syncExec(historyService.setRemovalTimeToHistoricProcessInstances().absoluteRemovalTime(DateTime.Now).byQuery(query).hierarchical().executeAsync()); historicRootProcessInstance = query.singleResult(); historicChildProcessInstance = historyService.createHistoricProcessInstanceQuery().superProcessInstanceId(historicRootProcessInstance.Id).singleResult(); // then assertThat(historicRootProcessInstance.RemovalTime, notNullValue()); assertThat(historicChildProcessInstance.RemovalTime, nullValue()); }
public virtual void testHistoryOfSetProcessDefinitionVersionCmd() { // given string resource = "org/camunda/bpm/engine/test/api/runtime/migration/SetProcessDefinitionVersionCmdTest.bpmn"; // Deployments org.camunda.bpm.engine.repository.Deployment firstDeployment = repositoryService.createDeployment().addClasspathResource(resource).deploy(); org.camunda.bpm.engine.repository.Deployment secondDeployment = repositoryService.createDeployment().addClasspathResource(resource).deploy(); // Process definitions ProcessDefinition processDefinitionV1 = repositoryService.createProcessDefinitionQuery().deploymentId(firstDeployment.Id).singleResult(); ProcessDefinition processDefinitionV2 = repositoryService.createProcessDefinitionQuery().deploymentId(secondDeployment.Id).singleResult(); // start process instance ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefinitionV1.Id); // when setProcessDefinitionVersion(processInstance.Id, 2); // then ProcessInstance processInstanceAfterMigration = runtimeService.createProcessInstanceQuery().processInstanceId(processInstance.Id).singleResult(); assertEquals(processDefinitionV2.Id, processInstanceAfterMigration.ProcessDefinitionId); if (processEngineConfiguration.HistoryLevel.Id > ProcessEngineConfigurationImpl.HISTORYLEVEL_NONE) { HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstance.Id).singleResult(); assertEquals(processDefinitionV2.Id, historicProcessInstance.ProcessDefinitionId); } // Clean up the test repositoryService.deleteDeployment(firstDeployment.Id, true); repositoryService.deleteDeployment(secondDeployment.Id, true); }