@Override public void execute(PerfTestRunContext context) { Execution execution = runtimeService.createExecutionQuery() .messageEventSubscriptionName(message) .processInstanceId((String)context.getVariable(processInstanceKey)) .singleResult(); runtimeService.messageEventReceived(message, execution.getId()); }
@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(); }
@Test public void testCompletePostParameters() { Map<String, String> queryParameters = getCompleteQueryParameters(); given().contentType(POST_JSON_CONTENT_TYPE).body(queryParameters) .expect().statusCode(Status.OK.getStatusCode()) .when().post(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(); }
@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); }
@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()); }
@Deployment @Test public void testExpressionInSingleIntermediateMessageEvent() { // given HashMap<String, Object> variables = new HashMap<String, Object>(); variables.put("foo", "bar"); // when ProcessInstance pi = runtimeService.startProcessInstanceByKey("process", variables); List<String> activeActivityIds = runtimeService.getActiveActivityIds(pi.getId()); assertNotNull(activeActivityIds); assertEquals(1, activeActivityIds.size()); assertTrue(activeActivityIds.contains("messageCatch")); // then String messageName = "newInvoiceMessage-bar"; Execution execution = runtimeService.createExecutionQuery() .messageEventSubscriptionName(messageName) .singleResult(); assertNotNull(execution); runtimeService.messageEventReceived(messageName, execution.getId()); Task task = taskService.createTaskQuery() .singleResult(); assertNotNull(task); taskService.complete(task.getId()); }
@Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/MessageCorrelationTest.testMatchingStartEventAndExecution.bpmn20.xml"}) @Test public void testMessageCorrelationResultWithResultTypeExecution() { //given String msgName = "newInvoiceMessage"; ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); assertNotNull(runtimeService.createExecutionQuery().messageEventSubscriptionName(msgName).singleResult()); //when //correlate message with result MessageCorrelationResult result = runtimeService.createMessageCorrelation(msgName).correlateWithResult(); //then //message correlation result contains information from receiver checkExecutionMessageCorrelationResult(result, processInstance, "messageCatch"); }
@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()); }
@Deployment @Test public void testConcurrentIntermediateMessageEvent() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("process"); List<String> activeActivityIds = runtimeService.getActiveActivityIds(pi.getId()); assertNotNull(activeActivityIds); assertEquals(2, activeActivityIds.size()); assertTrue(activeActivityIds.contains("messageCatch1")); assertTrue(activeActivityIds.contains("messageCatch2")); String messageName = "newInvoiceMessage"; List<Execution> executions = runtimeService.createExecutionQuery() .messageEventSubscriptionName(messageName) .list(); assertNotNull(executions); assertEquals(2, executions.size()); runtimeService.messageEventReceived(messageName, executions.get(0).getId()); Task task = taskService.createTaskQuery() .singleResult(); assertNull(task); runtimeService.messageEventReceived(messageName, executions.get(1).getId()); task = taskService.createTaskQuery() .singleResult(); assertNotNull(task); taskService.complete(task.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)); }
@Deployment public void testExpressionInBoundaryMessageEventName() { // given a process instance with its variables HashMap<String, Object> variables = new HashMap<String, Object>(); variables.put("foo", "bar"); runtimeService.startProcessInstanceByKey("process", variables); // when message is received Execution execution = runtimeService.createExecutionQuery() .messageEventSubscriptionName("messageName-bar") .singleResult(); assertNotNull(execution); runtimeService.messageEventReceived("messageName-bar", execution.getId()); // then then a task should be completed Task userTask = taskService.createTaskQuery().singleResult(); assertNotNull(userTask); assertEquals("taskAfterMessage", userTask.getTaskDefinitionKey()); taskService.complete(userTask.getId()); assertEquals(0, runtimeService.createProcessInstanceQuery().count()); }
@Deployment @Test public void testSingleIntermediateMessageEvent() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("process"); List<String> activeActivityIds = runtimeService.getActiveActivityIds(pi.getId()); assertNotNull(activeActivityIds); assertEquals(1, activeActivityIds.size()); assertTrue(activeActivityIds.contains("messageCatch")); String messageName = "newInvoiceMessage"; Execution execution = runtimeService.createExecutionQuery() .messageEventSubscriptionName(messageName) .singleResult(); assertNotNull(execution); runtimeService.messageEventReceived(messageName, execution.getId()); Task task = taskService.createTaskQuery() .singleResult(); assertNotNull(task); taskService.complete(task.getId()); }
@Test public void correlateReceivedMessageToIntermediateCatchEventNoAuthenticatedTenants() { testRule.deploy(MESSAGE_CATCH_PROCESS); engineRule.getRuntimeService().createProcessInstanceByKey("messageCatch").execute(); Execution execution = engineRule.getRuntimeService().createExecutionQuery() .processDefinitionKey("messageCatch") .messageEventSubscriptionName("message") .singleResult(); engineRule.getIdentityService().setAuthentication("user", null, null); engineRule.getRuntimeService().messageEventReceived("message", execution.getId()); engineRule.getIdentityService().clearAuthentication(); TaskQuery query = engineRule.getTaskService().createTaskQuery(); assertThat(query.count(), is(1L)); assertThat(query.withoutTenantId().count(), is(1L)); assertThat(query.tenantIdIn(TENANT_ONE).count(), is(0L)); }
@Test public void test() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcess"); long eventSubscriptionCount = runtimeService.createEventSubscriptionQuery().count(); assertEquals(1, eventSubscriptionCount); Execution execution = runtimeService.createExecutionQuery().messageEventSubscriptionName("Test Message").singleResult(); assertNotNull(execution); //runtimeService.messageEventReceived("Test Message", execution.getId()); runtimeService.createMessageCorrelation("Test Message").correlate(); eventSubscriptionCount = runtimeService.createEventSubscriptionQuery().count(); assertEquals(0, eventSubscriptionCount); assertEquals(0, runtimeService.createExecutionQuery().count()); }
@Test public void correlateReceivedMessageToIntermediateCatchEventDisabledTenantCheck() { testRule.deployForTenant(TENANT_ONE, MESSAGE_CATCH_PROCESS); testRule.deployForTenant(TENANT_TWO, MESSAGE_CATCH_PROCESS); engineRule.getProcessEngineConfiguration().setTenantCheckEnabled(false); engineRule.getIdentityService().setAuthentication("user", null, null); engineRule.getRuntimeService().createProcessInstanceByKey("messageCatch").processDefinitionTenantId(TENANT_ONE).execute(); engineRule.getRuntimeService().createProcessInstanceByKey("messageCatch").processDefinitionTenantId(TENANT_TWO).execute(); Execution execution = engineRule.getRuntimeService().createExecutionQuery() .processDefinitionKey("messageCatch") .messageEventSubscriptionName("message") .tenantIdIn(TENANT_ONE) .singleResult(); engineRule.getRuntimeService().messageEventReceived("message", execution.getId()); TaskQuery query = engineRule.getTaskService().createTaskQuery(); assertThat(query.count(), is(1L)); assertThat(query.tenantIdIn(TENANT_ONE).count(), is(1L)); assertThat(query.tenantIdIn(TENANT_TWO).count(), is(0L)); }
@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()); }
@Deployment public void testInterruptingBoundaryMessageEvent() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("process"); Execution execution = runtimeService.createExecutionQuery().messageEventSubscriptionName("newMessage").singleResult(); runtimeService.messageEventReceived("newMessage", execution.getId()); HistoricActivityInstanceQuery query = historyService.createHistoricActivityInstanceQuery(); query.activityId("message"); assertEquals(1, query.count()); assertNotNull(query.singleResult().getEndTime()); assertEquals("boundaryMessage", query.singleResult().getActivityType()); Task task = taskService.createTaskQuery().singleResult(); taskService.complete(task.getId()); assertProcessEnded(pi.getId()); }
@Deployment public void testNonInterruptingBoundaryMessageEvent() { ProcessInstance pi = runtimeService.startProcessInstanceByKey("process"); Execution execution = runtimeService.createExecutionQuery().messageEventSubscriptionName("newMessage").singleResult(); runtimeService.messageEventReceived("newMessage", execution.getId()); HistoricActivityInstanceQuery query = historyService.createHistoricActivityInstanceQuery(); query.activityId("message"); assertEquals(1, query.count()); assertNotNull(query.singleResult().getEndTime()); assertEquals("boundaryMessage", query.singleResult().getActivityType()); List<Task> tasks = taskService.createTaskQuery().list(); for (Task task : tasks) { taskService.complete(task.getId()); } assertProcessEnded(pi.getId()); }
private void testInterruptingUnderProcessDefinition(int expectedNumberOfEventSubscriptions) { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process"); // the process instance must have a message event subscription: Execution execution = runtimeService.createExecutionQuery() .executionId(processInstance.getId()) .messageEventSubscriptionName("newMessage") .singleResult(); assertNotNull(execution); assertEquals(expectedNumberOfEventSubscriptions, createEventSubscriptionQuery().count()); assertEquals(1, runtimeService.createExecutionQuery().count()); // if we trigger the usertask, the process terminates and the event subscription is removed: Task task = taskService.createTaskQuery().singleResult(); assertEquals("task", task.getTaskDefinitionKey()); taskService.complete(task.getId()); assertProcessEnded(processInstance.getId()); assertEquals(0, createEventSubscriptionQuery().count()); assertEquals(0, runtimeService.createExecutionQuery().count()); // now we start a new instance but this time we trigger the event subprocess: processInstance = runtimeService.startProcessInstanceByKey("process"); runtimeService.messageEventReceived("newMessage", processInstance.getId()); task = taskService.createTaskQuery().singleResult(); assertEquals("eventSubProcessTask", task.getTaskDefinitionKey()); taskService.complete(task.getId()); assertProcessEnded(processInstance.getId()); assertEquals(0, createEventSubscriptionQuery().count()); assertEquals(0, runtimeService.createExecutionQuery().count()); }