private void assertThatActivitiesHaveAllImportantInformation(IList <HistoricActivityInstance> completedHistoricActivityInstances)
{
HistoricActivityInstance startEvent = null, endEvent = null;
foreach (HistoricActivityInstance completedHistoricActivityInstance in completedHistoricActivityInstances)
{
if (completedHistoricActivityInstance.ActivityId.Equals("startEvent"))
{
startEvent = completedHistoricActivityInstance;
}
else if (completedHistoricActivityInstance.ActivityId.Equals("endEvent"))
{
endEvent = completedHistoricActivityInstance;
}
}
assertThat(startEvent, notNullValue());
assertThat(startEvent.ActivityName, @is("start"));
assertThat(startEvent.ActivityType, @is("startEvent"));
assertThat(startEvent.StartTime, notNullValue());
assertThat(startEvent.EndTime, notNullValue());
assertThat(startEvent.ProcessDefinitionKey, @is("process"));
assertThat(startEvent.ProcessDefinitionId, notNullValue());
assertThat(endEvent, notNullValue());
assertThat(endEvent.ActivityName, @is("end"));
assertThat(endEvent.ActivityType, @is("noneEndEvent"));
assertThat(endEvent.StartTime, notNullValue());
assertThat(endEvent.EndTime, notNullValue());
assertThat(endEvent.ProcessDefinitionKey, @is("process"));
assertThat(endEvent.ProcessDefinitionId, notNullValue());
}
public void TestHistoricActivityInstance1()
{
HistoricActivityInstance data = new HistoricActivityInstance();
data.Assignee = "Assigne";
data.BpmId = Guid.NewGuid().ToString();
data.BpmName = "BpmnName";
data.BpmType = "Type";
data.CalledProcessInstanceId = Guid.NewGuid().ToString();
data.DurationInMillis = 0;
data.EndTime = new DateTime();
data.ExecutionId = Guid.NewGuid().ToString();
data.Id = Guid.NewGuid().ToString();
data.ProcessDefinitionId = Guid.NewGuid().ToString();
data.ProcessInstanceId = Guid.NewGuid().ToString();
data.StartTime = new DateTime();
data.TaskId = Guid.NewGuid().ToString();
data.TenantId = "tenant";
Assert.IsNotNull(data.Assignee);
Assert.IsNotNull(data.BpmId);
Assert.IsNotNull(data.BpmName);
Assert.IsNotNull(data.BpmType);
Assert.IsNotNull(data.CalledProcessInstanceId);
Assert.IsNotNull(data.DurationInMillis);
Assert.IsNotNull(data.EndTime);
Assert.IsNotNull(data.ExecutionId);
Assert.IsNotNull(data.Id);
Assert.IsNotNull(data.ProcessDefinitionId);
Assert.IsNotNull(data.ProcessInstanceId);
Assert.IsNotNull(data.StartTime);
Assert.IsNotNull(data.TaskId);
Assert.IsNotNull(data.TenantId);
}
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);
}
public static HistoricActivityInstanceDto fromHistoricActivityInstance(HistoricActivityInstance historicActivityInstance)
{
HistoricActivityInstanceDto dto = new HistoricActivityInstanceDto();
dto.id = historicActivityInstance.Id;
dto.parentActivityInstanceId = historicActivityInstance.ParentActivityInstanceId;
dto.activityId = historicActivityInstance.ActivityId;
dto.activityName = historicActivityInstance.ActivityName;
dto.activityType = historicActivityInstance.ActivityType;
dto.processDefinitionKey = historicActivityInstance.ProcessDefinitionKey;
dto.processDefinitionId = historicActivityInstance.ProcessDefinitionId;
dto.processInstanceId = historicActivityInstance.ProcessInstanceId;
dto.executionId = historicActivityInstance.ExecutionId;
dto.taskId = historicActivityInstance.TaskId;
dto.calledProcessInstanceId = historicActivityInstance.CalledProcessInstanceId;
dto.calledCaseInstanceId = historicActivityInstance.CalledCaseInstanceId;
dto.assignee = historicActivityInstance.Assignee;
dto.startTime = historicActivityInstance.StartTime;
dto.endTime = historicActivityInstance.EndTime;
dto.durationInMillis = historicActivityInstance.DurationInMillis;
dto.canceled = historicActivityInstance.Canceled;
dto.completeScope = historicActivityInstance.CompleteScope;
dto.tenantId = historicActivityInstance.TenantId;
dto.removalTime = historicActivityInstance.RemovalTime;
dto.rootProcessInstanceId = historicActivityInstance.RootProcessInstanceId;
return(dto);
}
public virtual void testMigrateHistoryActivityInstance()
{
//given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.ONE_TASK_PROCESS).changeElementId("Process", "Process2").changeElementId("userTask", "userTask2").changeElementName("userTask", "new activity name"));
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
HistoricActivityInstanceQuery sourceHistoryActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
HistoricActivityInstanceQuery targetHistoryActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery().processDefinitionId(targetProcessDefinition.Id);
//when
assertEquals(2, sourceHistoryActivityInstanceQuery.count());
assertEquals(0, targetHistoryActivityInstanceQuery.count());
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
runtimeService.newMigration(migrationPlan).processInstanceQuery(sourceProcessInstanceQuery).execute();
// then one instance of the start event still belongs to the source process
// and one active user task instances is now migrated to the target process
assertEquals(1, sourceHistoryActivityInstanceQuery.count());
assertEquals(1, targetHistoryActivityInstanceQuery.count());
HistoricActivityInstance instance = targetHistoryActivityInstanceQuery.singleResult();
assertMigratedTo(instance, targetProcessDefinition, "userTask2");
assertEquals("new activity name", instance.ActivityName);
assertEquals(processInstance.Id, instance.ParentActivityInstanceId);
assertEquals("userTask", instance.ActivityType);
}
public ActivityPerfTestResult(HistoricActivityInstance historicActivity)
{
activityId = historicActivity.ActivityId;
activityInstanceId = historicActivity.Id;
processInstanceId = historicActivity.ProcessInstanceId;
startTime = historicActivity.StartTime;
endTime = historicActivity.EndTime;
duration = historicActivity.DurationInMillis;
}
private void assertThatActivitiesHaveAllImportantInformation(HistoricActivityInstance activityInstance)
{
assertThat(activityInstance, notNullValue());
assertThat(activityInstance.ActivityName, @is("task"));
assertThat(activityInstance.ActivityType, @is("userTask"));
assertThat(activityInstance.StartTime, notNullValue());
assertThat(activityInstance.EndTime, nullValue());
assertThat(activityInstance.ProcessDefinitionKey, @is("process"));
assertThat(activityInstance.ProcessDefinitionId, notNullValue());
}
private void createHistoricActivityInstanceMock()
{
IList <HistoricActivityInstance> activities = new List <HistoricActivityInstance>();
HistoricActivityInstance mockInstance = MockProvider.createMockHistoricActivityInstance();
activities.Add(mockInstance);
HistoricActivityInstanceQuery mockHistoricActivityInstanceQuery = mock(typeof(HistoricActivityInstanceQuery));
when(mockHistoricActivityInstanceQuery.list()).thenReturn(activities);
when(mockHistoryService.createHistoricActivityInstanceQuery()).thenReturn(mockHistoricActivityInstanceQuery);
}
private long searchForActivityIndex(IList <HistoricActivityInstance> historicActivityInstances, string activityId)
{
for (int i = 0; i < historicActivityInstances.Count; i++)
{
HistoricActivityInstance historicActivityInstance = historicActivityInstances[i];
if (historicActivityInstance.ActivityId.Equals(activityId))
{
return(i);
}
}
return(-1);
}
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 testSkipCustomListenerEnsureHistoryWritten()
{
// when creating the task skipping custom listeners
runtimeService.createProcessInstanceByKey("exclusiveGateway").startBeforeActivity("task2").execute(true, false);
// then the task assignment history (which uses a task listener) is written
Task task = taskService.createTaskQuery().taskDefinitionKey("task2").singleResult();
HistoricActivityInstance instance = historyService.createHistoricActivityInstanceQuery().activityId("task2").singleResult();
assertNotNull(instance);
assertEquals(task.Id, instance.TaskId);
assertEquals("kermit", instance.Assignee);
}
protected internal virtual void verifyOrder(HistoricActivityInstanceQuery query, params string[] expectedOrder)
{
assertEquals(expectedOrder.Length, query.count());
IList <HistoricActivityInstance> activityInstances = query.list();
for (int i = 0; i < expectedOrder.Length; i++)
{
HistoricActivityInstance activityInstance = activityInstances[i];
string currentActivityId = activityInstance.ActivityId;
string expectedActivityId = expectedOrder[i];
assertEquals(expectedActivityId, currentActivityId);
}
}
protected internal virtual HistoricActivityInstance resolveStartActivityInstance(HistoricProcessInstance processInstance)
{
HistoryService historyService = Context.ProcessEngineConfiguration.HistoryService;
string processInstanceId = processInstance.Id;
string startActivityId = processInstance.StartActivityId;
ensureNotNull("startActivityId", startActivityId);
IList <HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).activityId(startActivityId).orderPartiallyByOccurrence().asc().list();
ensureNotEmpty("historicActivityInstances", historicActivityInstances);
HistoricActivityInstance startActivityInstance = historicActivityInstances[0];
return(startActivityInstance);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void getRunningHistoricActivityInstances()
public virtual void getRunningHistoricActivityInstances()
{
// given
BpmnModelInstance simpleDefinition = Bpmn.createExecutableProcess("process").startEvent("startEvent").name("start").userTask("userTask").name("task").endEvent("endEvent").name("end").done();
testHelper.deploy(simpleDefinition);
runtimeService.startProcessInstanceByKey("process");
// when
IList <HistoricActivityInstance> runningHistoricActivityInstances = optimizeService.getRunningHistoricActivityInstances(pastDate(), null, 10);
// then
assertThat(runningHistoricActivityInstances.Count, @is(1));
HistoricActivityInstance activityInstance = runningHistoricActivityInstances[0];
assertThatActivitiesHaveAllImportantInformation(activityInstance);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testSetVariableLocalOnServiceTaskInsideParallelBranch()
public virtual void testSetVariableLocalOnServiceTaskInsideParallelBranch()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("process");
HistoricActivityInstance serviceTask = historyService.createHistoricActivityInstanceQuery().activityId("serviceTask1").singleResult();
assertNotNull(serviceTask);
HistoricVariableInstanceQuery query = historyService.createHistoricVariableInstanceQuery();
assertEquals(1, query.count());
HistoricVariableInstance variable = query.singleResult();
// the variable is in the service task scope
assertEquals(serviceTask.Id, variable.ActivityInstanceId);
assertProcessEnded(pi.Id);
}
protected internal virtual VariableMap collectInitialVariables(CommandContext commandContext, HistoricProcessInstance processInstance)
{
HistoryService historyService = commandContext.ProcessEngineConfiguration.HistoryService;
HistoricActivityInstance startActivityInstance = resolveStartActivityInstance(processInstance);
HistoricDetailQueryImpl query = (HistoricDetailQueryImpl)historyService.createHistoricDetailQuery().variableUpdates().executionId(processInstance.Id).activityInstanceId(startActivityInstance.Id);
IList <HistoricDetail> historicDetails = query.sequenceCounter(1).list();
VariableMap variables = new VariableMapImpl();
foreach (HistoricDetail detail in historicDetails)
{
HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate)detail;
variables.putValueTyped(variableUpdate.VariableName, variableUpdate.TypedValue);
}
return(variables);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Ignore("CAM-9354") @Test public void shouldHaveEqualParentActivityInstanceId()
public virtual void shouldHaveEqualParentActivityInstanceId()
{
// given
testHelper.deploy(Bpmn.createExecutableProcess("process").startEvent().subProcess("subprocess").embeddedSubProcess().startEvent().scriptTask("scriptTaskInSubprocess").scriptFormat("groovy").scriptText("throw new org.camunda.bpm.engine.delegate.BpmnError(\"anErrorCode\");").userTask().endEvent().subProcessDone().endEvent().moveToActivity("subprocess").boundaryEvent("boundary").error("anErrorCode").userTask("userTaskAfterBoundaryEvent").endEvent().done());
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
// when
runtimeService.createModification(processInstance.ProcessDefinitionId).startAfterActivity("scriptTaskInSubprocess").processInstanceIds(processInstance.Id).execute();
ActivityInstance activityInstance = runtimeService.getActivityInstance(processInstance.Id).getActivityInstances("subprocess")[0];
HistoricActivityInstance historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityId("subprocess").unfinished().singleResult();
// assume
assertNotNull(activityInstance);
assertNotNull(historicActivityInstance);
// then
assertEquals(historicActivityInstance.ParentActivityInstanceId, activityInstance.ParentActivityInstanceId);
}
protected internal virtual void assertMigratedTo(HistoricActivityInstance activityInstance, ProcessDefinition processDefinition, string activityId)
{
Assert.assertEquals(processDefinition.Id, activityInstance.ProcessDefinitionId);
Assert.assertEquals(processDefinition.Key, activityInstance.ProcessDefinitionKey);
Assert.assertEquals(activityId, activityInstance.ActivityId);
}
