@Deployment public void testDefaultSequenceFlowOnTask() { String procId = runtimeService.startProcessInstanceByKey("defaultSeqFlow", CollectionUtil.singletonMap("input", 2)).getId(); assertNotNull(runtimeService.createExecutionQuery().processInstanceId(procId).activityId("task2").singleResult()); procId = runtimeService.startProcessInstanceByKey("defaultSeqFlow", CollectionUtil.singletonMap("input", 3)).getId(); assertNotNull(runtimeService.createExecutionQuery().processInstanceId(procId).activityId("task3").singleResult()); procId = runtimeService.startProcessInstanceByKey("defaultSeqFlow", CollectionUtil.singletonMap("input", 123)).getId(); assertNotNull(runtimeService.createExecutionQuery().processInstanceId(procId).activityId("task1").singleResult()); }
@Override protected void applyFilters(ExecutionQuery query) { if (processDefinitionKey != null) { query.processDefinitionKey(processDefinitionKey); query.processInstanceBusinessKey(businessKey); query.processDefinitionId(processDefinitionId); query.processInstanceId(processInstanceId); query.activityId(activityId); query.signalEventSubscriptionName(signalEventSubscriptionName); query.messageEventSubscriptionName(messageEventSubscriptionName); query.active(); query.suspended(); query.incidentId(incidentId); query.incidentType(incidentType); query.incidentMessage(incidentMessage); query.incidentMessageLike(incidentMessageLike); query.tenantIdIn(tenantIdIn.toArray(new String[tenantIdIn.size()]));
public void testQueryByInvalidActivityId() { ExecutionQuery query = runtimeService.createExecutionQuery().activityId("invalid"); assertNull(query.singleResult()); assertEquals(0, query.list().size()); assertEquals(0, query.count()); }
@Override public void execute(PerfTestRunContext context) { Execution execution = runtimeService.createExecutionQuery() .messageEventSubscriptionName(message) .processInstanceId((String)context.getVariable(processInstanceKey)) .singleResult(); runtimeService.messageEventReceived(message, execution.getId()); }
protected Execution queryExecutionById(String id) { return runtimeService .createExecutionQuery() .executionId(id) .singleResult(); }
@Test public void testAdditionalParametersExcludingVariables() { Map<String, String> queryParameters = getCompleteQueryParameters(); given().queryParams(queryParameters) .expect().statusCode(Status.OK.getStatusCode()) .when().get(EXECUTION_QUERY_URL); verify(mockedQuery).processInstanceBusinessKey(queryParameters.get("businessKey")); verify(mockedQuery).processInstanceId(queryParameters.get("processInstanceId")); verify(mockedQuery).processDefinitionKey(queryParameters.get("processDefinitionKey")); verify(mockedQuery).processDefinitionId(queryParameters.get("processDefinitionId")); verify(mockedQuery).activityId(queryParameters.get("activityId")); verify(mockedQuery).signalEventSubscriptionName(queryParameters.get("signalEventSubscriptionName")); verify(mockedQuery).messageEventSubscriptionName(queryParameters.get("messageEventSubscriptionName")); verify(mockedQuery).active(); verify(mockedQuery).suspended(); verify(mockedQuery).incidentId(queryParameters.get("incidentId")); verify(mockedQuery).incidentMessage(queryParameters.get("incidentMessage")); verify(mockedQuery).incidentMessageLike(queryParameters.get("incidentMessageLike")); verify(mockedQuery).incidentType(queryParameters.get("incidentType")); verify(mockedQuery).list(); }
public JobAssert hasActivityId(final String activityId) { Execution execution = executionQuery().activityId(activityId).active().singleResult(); Assertions.assertThat(activityId).isNotNull(); String failureMessage = "Expecting %s to correspond to activity with id '%s', " + "but did not find that to be true"; Assertions.assertThat(execution) .overridingErrorMessage(failureMessage, toString(getExistingCurrent()), activityId) .isNotNull(); Assertions.assertThat(execution.getId()) .overridingErrorMessage(failureMessage, toString(getExistingCurrent()), activityId) .isEqualTo(actual.getExecutionId()); return this; }
@Deployment public void testExecutionExternalTask() { runtimeService.startProcessInstanceByKey("oneExternalTaskProcess"); ExecutionEntity execution = (ExecutionEntity) runtimeService .createExecutionQuery() .activityId("externalTask") .singleResult(); assertEquals(BitMaskUtil.getMaskForBit(ExecutionEntity.EXTERNAL_TASKS_BIT), execution.getCachedEntityStateRaw()); }
@Deployment @Test public void testMatchingStartEventAndExecution() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); assertNotNull(runtimeService.createExecutionQuery().messageEventSubscriptionName("newInvoiceMessage").singleResult()); // correlate message -> this will trigger the execution runtimeService.correlateMessage("newInvoiceMessage"); assertNull(runtimeService.createExecutionQuery().messageEventSubscriptionName("newInvoiceMessage").singleResult()); runtimeService.deleteProcessInstance(processInstance.getId(), null); // fluent builder ////////////////////// processInstance = runtimeService.startProcessInstanceByKey("process"); assertNotNull(runtimeService.createExecutionQuery().messageEventSubscriptionName("newInvoiceMessage").singleResult()); // correlate message -> this will trigger the execution runtimeService.createMessageCorrelation("newInvoiceMessage").correlate(); assertNull(runtimeService.createExecutionQuery().messageEventSubscriptionName("newInvoiceMessage").singleResult()); runtimeService.deleteProcessInstance(processInstance.getId(), null); }
private void createExecutionMock() { Execution mockExecution = MockProvider.createMockExecution(); ExecutionQuery mockExecutionQuery = mock(ExecutionQuery.class); when(mockExecutionQuery.processInstanceId(eq(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID))).thenReturn(mockExecutionQuery); when(mockExecutionQuery.singleResult()).thenReturn(mockExecution); when(mockRuntimeService.createExecutionQuery()).thenReturn(mockExecutionQuery); }
public void testQueryByInvalidProcessInstanceId() { ExecutionQuery query = runtimeService.createExecutionQuery().processInstanceId("invalid"); assertNull(query.singleResult()); assertEquals(0, query.list().size()); assertEquals(0, query.count()); }
@Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/MessageCorrelationTest.testMatchingStartEventAndExecution.bpmn20.xml"}) @Test public void testMatchingStartEventAndExecutionUsingFluentCorrelateAll() { runtimeService.startProcessInstanceByKey("process"); runtimeService.startProcessInstanceByKey("process"); assertEquals(2, runtimeService.createExecutionQuery().messageEventSubscriptionName("newInvoiceMessage").count()); // correlate message -> this will trigger the executions AND start a new process instance runtimeService.createMessageCorrelation("newInvoiceMessage").correlateAll(); assertNotNull(runtimeService.createExecutionQuery().messageEventSubscriptionName("newInvoiceMessage").singleResult()); assertEquals(3, runtimeService.createProcessInstanceQuery().count()); }
@Deployment(resources = "org/camunda/bpm/engine/test/bpmn/receivetask/ReceiveTaskTest.multiParallelReceiveTask.bpmn20.xml") public void testSupportsLegacySignalingOnParallelMultiReceiveTask() { // given: a process instance waiting in two receive tasks ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcess"); // expect: there are two message event subscriptions List<EventSubscription> subscriptions = getEventSubscriptionList(); assertEquals(2, subscriptions.size()); // expect: there are two executions List<Execution> executions = runtimeService.createExecutionQuery() .processInstanceId(processInstance.getId()).activityId("waitState") .messageEventSubscriptionName("newInvoiceMessage").list(); assertEquals(2, executions.size()); // then: we can signal both waiting receive task runtimeService.signal(executions.get(0).getId()); runtimeService.signal(executions.get(1).getId()); // expect: both event subscriptions are removed assertEquals(0, getEventSubscriptionList().size()); // expect: this ends the process instance assertProcessEnded(processInstance.getId()); }
@Test public void correlateReceivedMessageToIntermediateCatchEventWithAuthenticatedTenant() { testRule.deployForTenant(TENANT_ONE, MESSAGE_CATCH_PROCESS); engineRule.getRuntimeService().createProcessInstanceByKey("messageCatch").execute(); Execution execution = engineRule.getRuntimeService().createExecutionQuery() .processDefinitionKey("messageCatch") .messageEventSubscriptionName("message") .singleResult(); engineRule.getIdentityService().setAuthentication("user", null, Arrays.asList(TENANT_ONE)); engineRule.getRuntimeService().messageEventReceived("message", execution.getId()); engineRule.getIdentityService().clearAuthentication(); TaskQuery query = engineRule.getTaskService().createTaskQuery(); assertThat(query.count(), is(1L)); assertThat(query.tenantIdIn(TENANT_ONE).count(), is(1L)); }
public void testQueryByInvalidExecutionId() { ExecutionQuery query = runtimeService.createExecutionQuery().executionId("invalid"); assertNull(query.singleResult()); assertEquals(0, query.list().size()); assertEquals(0, query.count()); }
public void testQueryByInvalidProcessDefinitionKey() { ExecutionQuery query = runtimeService.createExecutionQuery().processDefinitionKey("invalid"); assertNull(query.singleResult()); assertEquals(0, query.list().size()); assertEquals(0, query.count()); }
@Deployment public void testTreeCompactionWithLocalVariableOnConcurrentExecution() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); Execution innerTaskExecution = runtimeService .createExecutionQuery() .activityId("innerTask") .singleResult(); Execution subProcessConcurrentExecution = runtimeService .createExecutionQuery() .executionId(((ExecutionEntity) innerTaskExecution).getParentId()) .singleResult(); Task task = taskService .createTaskQuery() .taskDefinitionKey("task") .singleResult(); // when runtimeService.setVariableLocal(subProcessConcurrentExecution.getId(), "foo", "bar"); // and completing the concurrent task, thereby pruning the sub process concurrent execution taskService.complete(task.getId()); // then the variable still exists VariableInstance variable = runtimeService.createVariableInstanceQuery().singleResult(); assertNotNull(variable); assertEquals("foo", variable.getName()); assertEquals(processInstance.getId(), variable.getExecutionId()); }
@Deployment(resources="org/camunda/bpm/engine/test/api/runtime/oneMessageCatchProcess.bpmn20.xml") public void testQueryForExecutionsWithMessageEventSubscriptionsOverlappingFilters() { ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneMessageCatchProcess"); Execution execution = runtimeService .createExecutionQuery() .messageEventSubscriptionName("newInvoiceMessage") .messageEventSubscription() .singleResult(); assertNotNull(execution); assertEquals(instance.getId(), execution.getProcessInstanceId()); runtimeService .createExecutionQuery() .messageEventSubscription() .messageEventSubscriptionName("newInvoiceMessage") .list(); assertNotNull(execution); assertEquals(instance.getId(), execution.getProcessInstanceId()); }
@Test public void failToCorrelateReceivedMessageToIntermediateCatchEventNoAuthenticatedTenants() { testRule.deployForTenant(TENANT_ONE, MESSAGE_CATCH_PROCESS); engineRule.getRuntimeService().createProcessInstanceByKey("messageCatch").processDefinitionTenantId(TENANT_ONE).execute(); Execution execution = engineRule.getRuntimeService().createExecutionQuery() .processDefinitionKey("messageCatch") .messageEventSubscriptionName("message") .tenantIdIn(TENANT_ONE) .singleResult(); // declare expected exception thrown.expect(ProcessEngineException.class); thrown.expectMessage("Cannot update the process instance"); engineRule.getIdentityService().setAuthentication("user", null, null); engineRule.getRuntimeService().messageEventReceived("message", execution.getId()); }
@Test public void createIncident() { //given testRule.deployAndGetDefinition(ProcessModels.TWO_TASKS_PROCESS); ProcessInstance processInstance = engineRule.getRuntimeService().startProcessInstanceByKey("Process"); ExecutionEntity execution = (ExecutionEntity) engineRule.getRuntimeService().createExecutionQuery().active().singleResult(); authRule .init(scenario) .withUser("userId") .bindResource("processInstance", processInstance.getId()) .bindResource("processDefinition", "Process") .start(); engineRule.getRuntimeService() .createIncident("foo", execution.getId(), execution.getActivityId(), "bar"); // then authRule.assertScenario(scenario); }