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