private void assertProcessInstance(ProcessInstance expected, ProcessInstance actual) { assertNotNull(actual); assertEquals(expected.getId(), actual.getId()); assertEquals(expected.getState(), actual.getState()); assertEquals(expected.getProcessId(), actual.getProcessId()); assertEquals(expected.getProcessName(), actual.getProcessName()); assertEquals(expected.getProcessVersion(), actual.getProcessVersion()); assertEquals(expected.getContainerId(), actual.getContainerId()); assertEquals(expected.getProcessInstanceDescription(), actual.getProcessInstanceDescription()); assertEquals(expected.getInitiator(), actual.getInitiator()); assertEquals(expected.getParentId(), actual.getParentId()); assertNotNull(actual.getCorrelationKey()); assertNotNull(actual.getDate()); }
@Test public void getProcessInstanceDetailsTest() { final Long processInstanceId = 1L; final TaskSummary taskSummaryMock = mock(TaskSummary.class); final TaskSummaryList taskSummaryListSpy = spy(new TaskSummaryList(singletonList(taskSummaryMock))); final ProcessInstance processInstanceSpy = spy(ProcessInstance.builder() .activeUserTasks(taskSummaryListSpy) .build()); when(queryServicesClient.findProcessInstanceById(processInstanceId)).thenReturn(processInstanceSpy); service.getProcessInstance(new ProcessInstanceKey(serverTemplateId, containerId, processInstanceId)); verify(processInstanceSpy).getProcessId(); verify(processInstanceSpy).getState(); verify(processInstanceSpy).getContainerId(); verify(processInstanceSpy).getProcessVersion(); verify(processInstanceSpy).getCorrelationKey(); verify(processInstanceSpy).getParentId(); verify(processInstanceSpy).getSlaCompliance(); verify(processInstanceSpy).getSlaDueDate(); verifyActiveUserTasks(taskSummaryListSpy, taskSummaryMock); verifyCurrentActivities(processInstanceId); }
processInstance.getId(), processInstance.getProcessId(), processInstance.getContainerId(), processInstance.getProcessName(), processInstance.getProcessVersion(), processInstance.getState(), processInstance.getDate(), null, processInstance.getInitiator(), processInstance.getProcessInstanceDescription(), processInstance.getCorrelationKey(), processInstance.getParentId(), null, processInstance.getSlaCompliance(), processInstance.getSlaDueDate(), if (processInstance.getActiveUserTasks() != null && processInstance.getActiveUserTasks().getTasks() != null) { List<TaskSummary> tasks = processInstance.getActiveUserTasks().getItems();
public String getProcessInstance(String containerId, Number processInstanceId, boolean withVars, String marshallingType) { ProcessInstanceDesc instanceDesc = runtimeDataService.getProcessInstanceById(processInstanceId.longValue()); if (instanceDesc == null) { throw new IllegalStateException("Unable to find process instance with id " + processInstanceId); } containerId = context.getContainerId(containerId, new ByProcessInstanceIdContainerLocator(processInstanceId.longValue())); org.kie.server.api.model.instance.ProcessInstance processInstance = convertToProcessInstance(instanceDesc); if (Boolean.TRUE.equals(withVars) && processInstance.getState().equals(ProcessInstance.STATE_ACTIVE)) { Map<String, Object> variables = processService.getProcessInstanceVariables(containerId, processInstanceId.longValue()); processInstance.setVariables(variables); } logger.debug("About to marshal process instance with id '{}' {}", processInstanceId, processInstance); String response = marshallerHelper.marshal(containerId, marshallingType, processInstance, new ByProcessInstanceIdContainerLocator(processInstanceId.longValue())); return response; }
@After public void abortAllProcesses() { List<Integer> status = new ArrayList<Integer>(); status.add(STATE_ACTIVE); List<ProcessInstance> activeInstances = queryClient.findProcessInstancesByStatus(status, 0, 100, CaseServicesClient.SORT_BY_PROCESS_INSTANCE_ID, false); if (activeInstances != null) { for (org.kie.server.api.model.instance.ProcessInstance instance : activeInstances) { processClient.abortProcessInstance(instance.getContainerId(), instance.getId()); } } }
@Test public void testGetProcessInstancesByProcessNameSortedByInstanceId() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("stringData", "waiting for signal"); parameters.put("personData", createPersonInstance(USER_JOHN)); List<Long> processInstanceIds = createProcessInstances(parameters); try { List<ProcessInstance> instances = queryClient.findProcessInstancesByProcessName("usertask", null, 0, 10, SORT_BY_INSTANCE_PROCESS_ID, false); assertNotNull(instances); assertEquals(2, instances.size()); assertEquals(PROCESS_ID_USERTASK, instances.get(0).getProcessId()); assertEquals(PROCESS_ID_USERTASK, instances.get(1).getProcessId()); assertTrue(instances.get(0).getId() > instances.get(1).getId()); } finally { abortProcessInstances(processInstanceIds); } }
@Test public void testCallWebServiceFromProcess() throws Exception { Map<String, Object> params = new HashMap<>(); params.put("serviceUrl", TestConfig.getWebServiceHttpURL()); Long pid = processClient.startProcess(WS_CONTAINER_ID, PROCESS_ID_WS, params); assertThat(pid).isNotNull(); ProcessInstance pi = queryClient.findProcessInstanceById(pid); assertThat(pi.getState()).isEqualTo(STATE_COMPLETED); }
assertEquals(org.kie.api.runtime.process.ProcessInstance.STATE_ACTIVE, processInstance.getState().intValue()); assertEquals(PROCESS_ID_EVALUATION, childInstance.getProcessId()); assertEquals(processInstanceId, childInstance.getParentId()); assertEquals("Call Evaluation", active.getName()); assertEquals("SubProcessNode", active.getNodeType()); assertEquals(childInstance.getId(), active.getReferenceId()); assertEquals(org.kie.api.runtime.process.ProcessInstance.STATE_ABORTED, processInstance.getState().intValue()); processInstance = processClient.getProcessInstance(CONTAINER_ID, childInstance.getId()); assertNotNull(processInstance); assertEquals(org.kie.api.runtime.process.ProcessInstance.STATE_ABORTED, processInstance.getState().intValue());
@Test public void testAddDynamicSubProcessToStage() { String caseId = startCarInsuranceClaimCase(USER_YODA, USER_JOHN, USER_YODA); Assertions.assertThat(caseId).isNotNull(); List<CaseStage> caseStages = caseClient.getStages(CONTAINER_ID, caseId, false, 0, 50); String activeStageId = caseStages.stream().filter(stage -> STAGE_ACTIVE_STATE.equals(stage.getStatus())) .findFirst() .orElseThrow(() -> new IllegalStateException("No active stage found.")) .getIdentifier(); List<ProcessInstance> instances = caseClient.getProcessInstances(CONTAINER_ID, caseId, Arrays.asList(1, 2, 3), 0, 10); Assertions.assertThat(instances).hasSize(1); final long originalCaseProcessInstanceId = instances.get(0).getId(); caseClient.addDynamicSubProcessToStage( CONTAINER_ID, caseId, activeStageId, DATA_VERIFICATION_DEF_ID, Collections.emptyMap()); instances = caseClient.getProcessInstances(CONTAINER_ID, caseId, Arrays.asList(1, 2, 3), 0, 10); Assertions.assertThat(instances).hasSize(2); final ProcessInstance newlyCreatedProcessInstance = instances.stream().filter((pi) -> pi.getId() != originalCaseProcessInstanceId) .findFirst() .get(); Assertions.assertThat(newlyCreatedProcessInstance.getProcessId()).isEqualTo(DATA_VERIFICATION_DEF_ID); Assertions.assertThat(newlyCreatedProcessInstance.getState()).isEqualTo(STATE_COMPLETED); }
assertThat(pi.getContainerId()).isEqualTo(CONTAINER_ID); assertThat(pi.getContainerId()).isEqualTo(CONTAINER_ID_2);
private void assertProcessInstance(Long pid, int processState, int slaStatus) { assertThat(pid).isNotNull(); ProcessInstance pi = queryClient.findProcessInstanceById(pid); assertThat(pi.getState()).isEqualTo(processState); assertThat(pi.getSlaCompliance()).isEqualTo(slaStatus); if (slaStatus != SLA_NA) { assertThat(pi.getSlaDueDate()).isCloseTo(new Date(), 30000); } }
@Test public void testGetProcessInstancesByCorrelationKeySortedById() throws Exception { CorrelationKeyFactory correlationKeyFactory = KieInternalServices.Factory.get().newCorrelationKeyFactory(); String firstBusinessKey = "my-simple-key-first"; String secondBusinessKey = "my-simple-key-second"; CorrelationKey firstKey = correlationKeyFactory.newCorrelationKey(firstBusinessKey); CorrelationKey secondKey = correlationKeyFactory.newCorrelationKey(secondBusinessKey); CorrelationKey partKey = correlationKeyFactory.newCorrelationKey("my-simple%"); Long processInstanceEvalutionId = processClient.startProcess(CONTAINER_ID, PROCESS_ID_EVALUATION, firstKey); Long processInstanceSignalId = processClient.startProcess(CONTAINER_ID, PROCESS_ID_SIGNAL_PROCESS, secondKey); try { List<ProcessInstance> returnedProcessInstances = queryClient.findProcessInstancesByCorrelationKey(partKey, 0, 100, SORT_BY_INSTANCE_PROCESS_ID, false); assertNotNull(returnedProcessInstances); assertProcessInstancesOrderById(returnedProcessInstances, false); ProcessInstance returnedSignalProcess = findProcessInstance(returnedProcessInstances, processInstanceSignalId); assertEquals(PROCESS_ID_SIGNAL_PROCESS, returnedSignalProcess.getProcessId()); assertEquals(processInstanceSignalId, returnedSignalProcess.getId()); assertEquals(secondBusinessKey, returnedSignalProcess.getCorrelationKey()); ProcessInstance returnedEvaluation = findProcessInstance(returnedProcessInstances, processInstanceEvalutionId); assertEquals(PROCESS_ID_EVALUATION, returnedEvaluation.getProcessId()); assertEquals(processInstanceEvalutionId, returnedEvaluation.getId()); assertEquals(firstBusinessKey, returnedEvaluation.getCorrelationKey()); } finally { processClient.abortProcessInstance(CONTAINER_ID, processInstanceEvalutionId); processClient.abortProcessInstance(CONTAINER_ID, processInstanceSignalId); } }
protected List<Long> collectInstances(List<ProcessInstance> instances) { List<Long> ids = new ArrayList<Long>(); for (ProcessInstance instance : instances) { ids.add(instance.getId()); } return ids; }
@Test public void testGetProcessInstanceDiagramSummaryCompletedStatus() { ProcessInstanceKey instanceKey = new ProcessInstanceKey(serverTemplateId, containerId, processInstanceId); String svgContent = "<svg></svg>"; Integer state = org.kie.api.runtime.process.ProcessInstance.STATE_COMPLETED; String processName = "process"; when(queryServicesClient.findProcessInstanceById(processInstanceId)).thenReturn(ProcessInstance.builder().id(processInstanceId).processId(processId).containerId(containerId).state(state).processName(processName).build()); when(processImageService.getProcessInstanceDiagram(serverTemplateId, containerId, processInstanceId)).thenReturn(svgContent); when(processServicesClient.getProcessDefinition(containerId, processId)).thenReturn(new ProcessDefinition()); ProcessInstanceDiagramSummary summary = service.getProcessInstanceDiagramSummary(instanceKey); assertEquals(processInstanceId, summary.getId()); assertEquals(processName, summary.getName()); assertEquals(svgContent, summary.getSvgContent()); assertNotNull(summary.getProcessDefinition()); assertThat(summary.getProcessDefinition().getNodes()).isEmpty(); assertThat(summary.getProcessDefinition().getTimers()).isEmpty(); assertThat(summary.getNodeInstances()).isEmpty(); assertThat(summary.getTimerInstances()).isEmpty(); verify(queryServicesClient, never()).findActiveNodeInstances(any(), any(), any()); verify(queryServicesClient, never()).findCompletedNodeInstances(any(), any(), any()); verify(processAdminServicesClient, never()).getTimerInstances(any(), any()); }
@Test public void testGetProcessInstancesSorting() { String carInsuranceClaimCase = startCarInsuranceClaimCase(USER_JOHN, USER_YODA, USER_YODA); caseClient.addDynamicSubProcess(CONTAINER_ID, carInsuranceClaimCase, DATA_VERIFICATION_DEF_ID, new HashMap<>()); List<ProcessInstance> processInstances = caseClient.getProcessInstances(CONTAINER_ID, carInsuranceClaimCase, Arrays.asList(STATE_ACTIVE, STATE_COMPLETED), 0, 1, CaseServicesClient.SORT_BY_PROCESS_INSTANCE_ID, true); assertNotNull(processInstances); assertEquals(1, processInstances.size()); assertEquals(processInstances.get(0).getProcessId(), CLAIM_CASE_DEF_ID); processInstances = caseClient.getProcessInstances(CONTAINER_ID, carInsuranceClaimCase, Arrays.asList(STATE_ACTIVE, STATE_COMPLETED), 1, 1, CaseServicesClient.SORT_BY_PROCESS_INSTANCE_ID, true); assertNotNull(processInstances); assertEquals(1, processInstances.size()); assertEquals(processInstances.get(0).getProcessId(), DATA_VERIFICATION_DEF_ID); processInstances = caseClient.getProcessInstances(CONTAINER_ID, carInsuranceClaimCase, Arrays.asList(STATE_ACTIVE, STATE_COMPLETED), 0, 10, CaseServicesClient.SORT_BY_PROCESS_INSTANCE_ID, false); assertNotNull(processInstances); assertEquals(2, processInstances.size()); assertEquals(processInstances.get(0).getProcessId(), DATA_VERIFICATION_DEF_ID); assertEquals(processInstances.get(1).getProcessId(), CLAIM_CASE_DEF_ID); }
assertEquals(CASE_HR_DEF_ID, pi.getProcessId()); assertEquals(caseId, pi.getCorrelationKey());
assertEquals(2, instances.size()); long pi1 = instances.get(0).getId(); long pi2 = instances.get(1).getId(); final Map<String, Object> variables = instance.getVariables(); assertNotNull(variables); assertEquals(2, variables.size());
org.kie.server.api.model.instance.ProcessInstance instance = org.kie.server.api.model.instance.ProcessInstance.builder() .id(pi.getId()) .processId(pi.getProcessId()) counter++; instance.setActiveUserTasks(new TaskSummaryList(tasks));
@Test public void testStartCheckProcessWithCorrelationKey() throws Exception { String firstSimpleKey = "first-simple-key"; String secondSimpleKey = "second-simple-key"; String stringVarName = "stringData"; String stringVarValue = "string variable test"; CorrelationKeyFactory correlationKeyFactory = KieInternalServices.Factory.get().newCorrelationKeyFactory(); CorrelationKey firstKey = correlationKeyFactory.newCorrelationKey(firstSimpleKey); CorrelationKey secondKey = correlationKeyFactory.newCorrelationKey(secondSimpleKey); Long firstProcessInstanceId = processClient.startProcess(CONTAINER_ID, PROCESS_ID_EVALUATION, firstKey); Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put(stringVarName, stringVarValue); Long secondProcessInstanceId = processClient.startProcess(CONTAINER_ID, PROCESS_ID_EVALUATION, secondKey, parameters); try { ProcessInstance instance = processClient.getProcessInstance(CONTAINER_ID, firstProcessInstanceId); ProcessInstance expected = createEvaluationProcessInstace(firstProcessInstanceId); assertProcessInstance(expected, instance); assertEquals(firstSimpleKey, instance.getCorrelationKey()); instance = processClient.getProcessInstance(CONTAINER_ID, secondProcessInstanceId, true); expected = createEvaluationProcessInstace(secondProcessInstanceId); assertProcessInstance(expected, instance); assertEquals(secondSimpleKey, instance.getCorrelationKey()); assertTrue(instance.getVariables().containsKey(stringVarName)); assertEquals(stringVarValue, instance.getVariables().get(stringVarName)); } finally { processClient.abortProcessInstance(CONTAINER_ID, firstProcessInstanceId); processClient.abortProcessInstance(CONTAINER_ID, secondProcessInstanceId); } }
@Test(timeout = 60 * 1000) public void testTimerStartEvent() throws Exception { String containerId = "timer-project-" + runtimeStrategy; createContainer(containerId, releaseId, new KieServerConfigItem(KieServerConstants.PCFG_RUNTIME_STRATEGY, runtimeStrategy, String.class.getName())); List<Integer> completedOnly = Arrays.asList(2); KieServerSynchronization.waitForProcessInstanceStart(queryClient, containerId, 3, completedOnly); List<ProcessInstance> startedInstances = queryClient.findProcessInstancesByContainerId(containerId, completedOnly, 0, 10, "Id", false); assertEquals(3, startedInstances.size()); long thirdInstance = startedInstances.get(0).getDate().getTime(); long secondInstance = startedInstances.get(1).getDate().getTime(); long firstInstance = startedInstances.get(2).getDate().getTime(); // let's round it up to be on simple value double distance1 = Math.ceil((thirdInstance - secondInstance)); double distance2 = Math.ceil((secondInstance - firstInstance)); // since the expiration time is 5 seconds let's make sure it's not more than doubled of expiration time assertTrue(distance1 < 10000); assertTrue(distance2 < 10000); } }