private long searchForActivityIndex(List<HistoricActivityInstance> historicActivityInstances, String activityId) { for (int i = 0; i < historicActivityInstances.size(); i++) { HistoricActivityInstance historicActivityInstance = historicActivityInstances.get(i); if (historicActivityInstance.getActivityId().equals(activityId)) { return i; } } return -1; }
public ActivityPerfTestResult(HistoricActivityInstance historicActivity) { activityId = historicActivity.getActivityId(); activityInstanceId = historicActivity.getId(); processInstanceId = historicActivity.getProcessInstanceId(); startTime = historicActivity.getStartTime(); endTime = historicActivity.getEndTime(); duration = historicActivity.getDurationInMillis(); }
private void assertThatActivitiesHaveAllImportantInformation(List<HistoricActivityInstance> completedHistoricActivityInstances) { HistoricActivityInstance startEvent = null, endEvent = null; for (HistoricActivityInstance completedHistoricActivityInstance : completedHistoricActivityInstances) { if (completedHistoricActivityInstance.getActivityId().equals("startEvent")) { startEvent = completedHistoricActivityInstance; } else if (completedHistoricActivityInstance.getActivityId().equals("endEvent")) { endEvent = completedHistoricActivityInstance; } } assertThat(startEvent, notNullValue()); assertThat(startEvent.getActivityName(), is("start")); assertThat(startEvent.getActivityType(), is("startEvent")); assertThat(startEvent.getStartTime(), notNullValue()); assertThat(startEvent.getEndTime(), notNullValue()); assertThat(startEvent.getProcessDefinitionKey(), is("process")); assertThat(startEvent.getProcessDefinitionId(), notNullValue()); assertThat(endEvent, notNullValue()); assertThat(endEvent.getActivityName(), is("end")); assertThat(endEvent.getActivityType(), is("noneEndEvent")); assertThat(endEvent.getStartTime(), notNullValue()); assertThat(endEvent.getEndTime(), notNullValue()); assertThat(endEvent.getProcessDefinitionKey(), is("process")); assertThat(endEvent.getProcessDefinitionId(), notNullValue()); }
public static HistoricActivityInstance createMockRunningHistoricActivityInstance() { HistoricActivityInstance mock = mock(HistoricActivityInstance.class); when(mock.getId()).thenReturn(EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_ID); when(mock.getParentActivityInstanceId()).thenReturn(EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_PARENT_ACTIVITY_INSTANCE_ID); when(mock.getActivityId()).thenReturn(EXAMPLE_ACTIVITY_ID); when(mock.getActivityName()).thenReturn(EXAMPLE_ACTIVITY_NAME); when(mock.getActivityType()).thenReturn(EXAMPLE_ACTIVITY_TYPE); when(mock.getProcessDefinitionId()).thenReturn(EXAMPLE_PROCESS_DEFINITION_ID); when(mock.getProcessInstanceId()).thenReturn(EXAMPLE_PROCESS_INSTANCE_ID); when(mock.getExecutionId()).thenReturn(EXAMPLE_EXECUTION_ID); when(mock.getTaskId()).thenReturn(EXAMPLE_TASK_ID); when(mock.getCalledProcessInstanceId()).thenReturn(EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_CALLED_PROCESS_INSTANCE_ID); when(mock.getCalledCaseInstanceId()).thenReturn(EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_CALLED_CASE_INSTANCE_ID); when(mock.getAssignee()).thenReturn(EXAMPLE_TASK_ASSIGNEE_NAME); when(mock.getStartTime()).thenReturn(DateTimeUtil.parseDate(EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_START_TIME)); when(mock.getEndTime()).thenReturn(null); when(mock.getDurationInMillis()).thenReturn(null); return mock; }
@Deployment(resources = "org/camunda/bpm/engine/test/history/HistoricActivityInstanceTest.testHistoricActivityInstanceQueryByCompleteScope.bpmn") public void testHistoricActivityInstanceQueryByCanceled() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); runtimeService.deleteProcessInstance(processInstance.getId(), "test"); HistoricActivityInstanceQuery query = historyService.createHistoricActivityInstanceQuery().canceled(); assertEquals(3, query.count()); List<HistoricActivityInstance> instances = query.list(); for (HistoricActivityInstance instance : instances) { if (!instance.getActivityId().equals("subprocess") && !instance.getActivityId().equals("userTask1") && !instance.getActivityId().equals("userTask2")) { fail("Unexpected instance with activity id " + instance.getActivityId() + " found."); } } assertProcessEnded(processInstance.getId()); }
private void assertCorrectCanceledState(List<HistoricActivityInstance> allInstances, String activityId, int expectedCount, boolean canceled) { int found = 0; for (HistoricActivityInstance instance : allInstances) { if (instance.getActivityId().equals(activityId)) { found++; assertEquals(String.format("expect <%s> to be %scanceled", activityId, (canceled ? "" : "non-")), canceled, instance.isCanceled()); } } assertTrue("contains entry for activity <" + activityId + ">", found > 0); if (expectedCount != -1) { assertTrue("contains <" + expectedCount + "> entries for activity <" + activityId + ">", found == expectedCount); } }
private void assertCorrectCompletingState(List<HistoricActivityInstance> allInstances, String activityId, int expectedCount, boolean completing) { int found = 0; for (HistoricActivityInstance instance : allInstances) { if (instance.getActivityId().equals(activityId)) { found++; assertEquals(String.format("expect <%s> to be %scompleting", activityId, (completing ? "" : "non-")), completing, instance.isCompleteScope()); } } assertTrue("contains entry for activity <" + activityId + ">", found > 0); if (expectedCount != -1) { assertTrue("contains <" + expectedCount + "> entries for activity <" + activityId + ">", found == expectedCount); } }
protected void verifyOrder(HistoricActivityInstanceQuery query, String... expectedOrder) { assertEquals(expectedOrder.length, query.count()); List<HistoricActivityInstance> activityInstances = query.list(); for (int i = 0; i < expectedOrder.length; i++) { HistoricActivityInstance activityInstance = activityInstances.get(i); String currentActivityId = activityInstance.getActivityId(); String expectedActivityId = expectedOrder[i]; assertEquals(expectedActivityId, currentActivityId); } }
protected void logActivityResults(PerfTestPass pass, PerfTestRun run, HistoryService historyService) { String processInstanceId = run.getVariable(PerfTestConstants.PROCESS_INSTANCE_ID); List<ActivityPerfTestResult> activityResults = new ArrayList<ActivityPerfTestResult>(); HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult(); Date startTime = processInstance.getStartTime(); List<HistoricActivityInstance> activityInstances = historyService.createHistoricActivityInstanceQuery() .processInstanceId(processInstanceId) .orderByHistoricActivityInstanceStartTime() .asc() .list(); for (HistoricActivityInstance activityInstance : activityInstances) { if (watchAllActivities || activityIds.contains(activityInstance.getActivityId())) { ActivityPerfTestResult result = new ActivityPerfTestResult(activityInstance); if (activityInstance.getActivityType().equals("startEvent")) { result.setStartTime(startTime); } activityResults.add(result); } } pass.logActivityResult(processInstanceId, activityResults); }
@Test public void fishedAfterParameterWorks() { // given BpmnModelInstance simpleDefinition = Bpmn.createExecutableProcess("process") .startEvent() .userTask("userTask") .endEvent("endEvent") .done(); testHelper.deploy(simpleDefinition); Date now = new Date(); Date nowPlus2Seconds = new Date(now.getTime() + 2000L); ClockUtil.setCurrentTime(now); engineRule.getRuntimeService().startProcessInstanceByKey("process"); // when ClockUtil.setCurrentTime(nowPlus2Seconds); completeAllUserTasks(); List<HistoricActivityInstance> completedHistoricActivityInstances = optimizeService.getCompletedHistoricActivityInstances(now, null, 10); // then Set<String> allowedActivityIds = new HashSet<>(Arrays.asList("userTask", "endEvent")); assertThat(completedHistoricActivityInstances.size(), is(2)); assertTrue(allowedActivityIds.contains(completedHistoricActivityInstances.get(0).getActivityId())); assertTrue(allowedActivityIds.contains(completedHistoricActivityInstances.get(1).getActivityId())); }
@Deployment public void testHistoricActivityInstanceQueryByCompleteScope() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); List<Task> tasks = taskService.createTaskQuery().list(); for (Task task : tasks) { taskService.complete(task.getId()); } HistoricActivityInstanceQuery query = historyService.createHistoricActivityInstanceQuery().completeScope(); assertEquals(3, query.count()); List<HistoricActivityInstance> instances = query.list(); for (HistoricActivityInstance instance : instances) { if (!instance.getActivityId().equals("innerEnd") && !instance.getActivityId().equals("end1") && !instance.getActivityId().equals("end2")) { fail("Unexpected instance with activity id " + instance.getActivityId() + " found."); } } assertProcessEnded(processInstance.getId()); }
@Deployment public void testEventLinkMultipleSources() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("linkEventValid"); List<String> activeActivities = runtimeService.getActiveActivityIds(pi.getId()); // assert that the link event was triggered and that we are assertEquals(Arrays.asList(new String []{"WaitAfterLink", "WaitAfterLink"}), activeActivities); runtimeService.deleteProcessInstance(pi.getId(), "test done"); // validate history if(processEngineConfiguration.getHistoryLevel().getId() >= ProcessEngineConfigurationImpl.HISTORYLEVEL_ACTIVITY) { List<HistoricActivityInstance> activities = historyService.createHistoricActivityInstanceQuery().processInstanceId(pi.getId()).orderByActivityId().asc().list(); assertEquals(5, activities.size()); assertEquals("ManualTask_1", activities.get(0).getActivityId()); assertEquals("ParallelGateway_1", activities.get(1).getActivityId()); assertEquals("StartEvent_1", activities.get(2).getActivityId()); assertEquals("WaitAfterLink", activities.get(3).getActivityId()); assertEquals("WaitAfterLink", activities.get(4).getActivityId()); } }
@Test public void fetchOnlyCompletedActivities() { // given BpmnModelInstance simpleDefinition = Bpmn.createExecutableProcess("process") .startEvent("startEvent") .userTask() .endEvent() .done(); testHelper.deploy(simpleDefinition); engineRule.getRuntimeService().startProcessInstanceByKey("process"); // when List<HistoricActivityInstance> completedHistoricActivityInstances = optimizeService.getCompletedHistoricActivityInstances(pastDate(), null, 10); // then assertThat(completedHistoricActivityInstances.size(), is(1)); assertThat(completedHistoricActivityInstances.get(0).getActivityId(), is("startEvent")); }
@Test public void fishedAtParameterWorks() { // given BpmnModelInstance simpleDefinition = Bpmn.createExecutableProcess("process") .startEvent("startEvent") .userTask("userTask") .endEvent("endEvent") .done(); testHelper.deploy(simpleDefinition); Date now = new Date(); Date nowPlus2Seconds = new Date(now.getTime() + 2000L); ClockUtil.setCurrentTime(now); engineRule.getRuntimeService().startProcessInstanceByKey("process"); // when ClockUtil.setCurrentTime(nowPlus2Seconds); completeAllUserTasks(); List<HistoricActivityInstance> completedHistoricActivityInstances = optimizeService.getCompletedHistoricActivityInstances(null, now, 10); // then assertThat(completedHistoricActivityInstances.size(), is(1)); assertThat(completedHistoricActivityInstances.get(0).getActivityId(), is("startEvent")); }
@Test public void fetchOnlyRunningActivities() { // given BpmnModelInstance simpleDefinition = Bpmn.createExecutableProcess("process") .startEvent("startEvent") .userTask("userTask") .endEvent() .done(); testHelper.deploy(simpleDefinition); engineRule.getRuntimeService().startProcessInstanceByKey("process"); // when List<HistoricActivityInstance> runningHistoricActivityInstances = optimizeService.getRunningHistoricActivityInstances(pastDate(), null, 10); // then assertThat(runningHistoricActivityInstances.size(), is(1)); assertThat(runningHistoricActivityInstances.get(0).getActivityId(), is("userTask")); // when completeAllUserTasks(); runningHistoricActivityInstances = optimizeService.getRunningHistoricActivityInstances(pastDate(), null, 10); // then assertThat(runningHistoricActivityInstances.size(), is(0)); }
@Deployment(resources="org/camunda/bpm/engine/test/bpmn/multiinstance/MultiInstanceTest.testParallelUserTasksBasedOnCollection.bpmn20.xml") public void testEmptyCollectionInMI() { List<String> assigneeList = new ArrayList<String>(); String procId = runtimeService.startProcessInstanceByKey("miParallelUserTasksBasedOnCollection", CollectionUtil.singletonMap("assigneeList", assigneeList)).getId(); assertEquals(0, taskService.createTaskQuery().count()); assertProcessEnded(procId); if (processEngineConfiguration.getHistoryLevel().getId() > ProcessEngineConfigurationImpl.HISTORYLEVEL_NONE) { List<HistoricActivityInstance> activities = historyService .createHistoricActivityInstanceQuery() .processInstanceId(procId) .orderByActivityId() .asc().list(); assertEquals(3, activities.size()); assertEquals("miTasks#multiInstanceBody", activities.get(0).getActivityId()); assertEquals("theEnd", activities.get(1).getActivityId()); assertEquals("theStart", activities.get(2).getActivityId()); } }
@Deployment public void testValidEventLink() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("linkEventValid"); List<String> activeActivities = runtimeService.getActiveActivityIds(pi.getId()); // assert that now the first receive task is active assertEquals(Arrays.asList(new String []{"waitAfterLink1"}), activeActivities); runtimeService.signal(pi.getId()); activeActivities = runtimeService.getActiveActivityIds(pi.getId()); // assert that now the second receive task is active assertEquals(Arrays.asList(new String []{"waitAfterLink2"}), activeActivities); runtimeService.signal(pi.getId()); assertProcessEnded(pi.getId()); // validate history if(processEngineConfiguration.getHistoryLevel().getId() >= ProcessEngineConfigurationImpl.HISTORYLEVEL_ACTIVITY) { List<HistoricActivityInstance> activities = historyService.createHistoricActivityInstanceQuery().processInstanceId(pi.getId()).orderByActivityId().asc().list(); assertEquals(4, activities.size()); assertEquals("EndEvent_1", activities.get(0).getActivityId()); assertEquals("StartEvent_1", activities.get(1).getActivityId()); assertEquals("waitAfterLink1", activities.get(2).getActivityId()); assertEquals("waitAfterLink2", activities.get(3).getActivityId()); } }
protected void assertMigratedTo(HistoricActivityInstance activityInstance, ProcessDefinition processDefinition, String activityId) { Assert.assertEquals(processDefinition.getId(), activityInstance.getProcessDefinitionId()); Assert.assertEquals(processDefinition.getKey(), activityInstance.getProcessDefinitionKey()); Assert.assertEquals(activityId, activityInstance.getActivityId()); }
@Test @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL) public void testHistoricProcInstQueryWithActiveActivityIds() { // given deployment(ProcessModels.TWO_TASKS_PROCESS); ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process"); // assume HistoricActivityInstance historicActivityInstance = historyService .createHistoricActivityInstanceQuery() .activityId("userTask1") .singleResult(); assertNotNull(historicActivityInstance); // when List<HistoricProcessInstance> result = historyService .createHistoricProcessInstanceQuery() .activeActivityIdIn(historicActivityInstance.getActivityId()) .list(); // then assertNotNull(result); assertEquals(1, result.size()); assertEquals(result.get(0).getId(), processInstance.getId()); }
@Deployment public void testHistoricActivityInstanceNoop() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("noopProcess"); HistoricActivityInstance historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityId("noop").singleResult(); assertEquals("noop", historicActivityInstance.getActivityId()); assertEquals("serviceTask", historicActivityInstance.getActivityType()); assertNotNull(historicActivityInstance.getProcessDefinitionId()); assertEquals(processInstance.getId(), historicActivityInstance.getProcessInstanceId()); assertEquals(processInstance.getId(), historicActivityInstance.getExecutionId()); assertNotNull(historicActivityInstance.getStartTime()); assertNotNull(historicActivityInstance.getEndTime()); assertTrue(historicActivityInstance.getDurationInMillis() >= 0); }