private void setUpMockDefinitionQuery(ProcessDefinition mockDefinition) { processDefinitionQueryMock = mock(ProcessDefinitionQuery.class); when(processDefinitionQueryMock.processDefinitionKey(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY)).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.processDefinitionId(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID)).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.tenantIdIn(anyString())).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.withoutTenantId()).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.latestVersion()).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.singleResult()).thenReturn(mockDefinition); when(processDefinitionQueryMock.count()).thenReturn(1L); when(processDefinitionQueryMock.list()).thenReturn(Collections.singletonList(mockDefinition)); when(repositoryServiceMock.createProcessDefinitionQuery()).thenReturn(processDefinitionQueryMock); }
private void setupProcessDefinitionMock() { ProcessDefinition mockDefinition = MockProvider.createMockDefinition(); processDefinitionQueryMock = mock(ProcessDefinitionQuery.class); when(processDefinitionQueryMock.processDefinitionKey(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY)).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.tenantIdIn(anyString())).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.withoutTenantId()).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.latestVersion()).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.singleResult()).thenReturn(mockDefinition); when(processDefinitionQueryMock.list()).thenReturn(Collections.singletonList(mockDefinition)); when(processDefinitionQueryMock.count()).thenReturn(1L); when(processEngine.getRepositoryService().createProcessDefinitionQuery()).thenReturn(processDefinitionQueryMock); }
public void testQueryByDefinitionsWithoutTenantId() { ProcessDefinitionQuery query = repositoryService .createProcessDefinitionQuery() .withoutTenantId(); assertThat(query.count(), is(1L)); }
@Before public void setUpHttpClientAndRuntimeData() { client = HttpClients.createDefault(); reqConfig = RequestConfig.custom().setConnectTimeout(3 * 60 * 1000).setSocketTimeout(10 * 60 * 1000).build(); ProcessDefinition mockDefinition = MockProvider.createMockDefinition(); runtimeServiceMock = mock(RuntimeService.class); when(processEngine.getRuntimeService()).thenReturn(runtimeServiceMock); mockInstantiationBuilder = mock(ProcessInstantiationBuilder.class); when(mockInstantiationBuilder.setVariables(any(Map.class))).thenReturn(mockInstantiationBuilder); when(mockInstantiationBuilder.businessKey(anyString())).thenReturn(mockInstantiationBuilder); when(mockInstantiationBuilder.caseInstanceId(anyString())).thenReturn(mockInstantiationBuilder); when(runtimeServiceMock.createProcessInstanceById(anyString())).thenReturn(mockInstantiationBuilder); ProcessInstanceWithVariables resultInstanceWithVariables = MockProvider.createMockInstanceWithVariables(); when(mockInstantiationBuilder.executeWithVariablesInReturn(anyBoolean(), anyBoolean())).thenReturn(resultInstanceWithVariables); ProcessDefinitionQuery processDefinitionQueryMock = mock(ProcessDefinitionQuery.class); when(processDefinitionQueryMock.processDefinitionKey(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY)).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.withoutTenantId()).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.latestVersion()).thenReturn(processDefinitionQueryMock); when(processDefinitionQueryMock.singleResult()).thenReturn(mockDefinition); RepositoryService repositoryServiceMock = mock(RepositoryService.class); when(processEngine.getRepositoryService()).thenReturn(repositoryServiceMock); when(repositoryServiceMock.createProcessDefinitionQuery()).thenReturn(processDefinitionQueryMock); }
public ProcessDefinitionResource getProcessDefinitionByKey(String processDefinitionKey) { ProcessDefinition processDefinition = getProcessEngine() .getRepositoryService() .createProcessDefinitionQuery() .processDefinitionKey(processDefinitionKey) .withoutTenantId() .latestVersion() .singleResult(); if(processDefinition == null){ String errorMessage = String.format("No matching process definition with key: %s and no tenant-id", processDefinitionKey); throw new RestException(Status.NOT_FOUND, errorMessage); } else { return getProcessDefinitionById(processDefinition.getId()); } }
public ProcessDefinitionResource getProcessDefinitionByKey(String processDefinitionKey) { ProcessDefinition processDefinition = getProcessEngine() .getRepositoryService() .createProcessDefinitionQuery() .processDefinitionKey(processDefinitionKey) .withoutTenantId() .latestVersion() .singleResult(); if(processDefinition == null){ String errorMessage = String.format("No matching process definition with key: %s and no tenant-id", processDefinitionKey); throw new RestException(Status.NOT_FOUND, errorMessage); } else { return getProcessDefinitionById(processDefinition.getId()); } }
public void testQueryAuthenticatedTenants() { identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO)); ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery(); assertThat(query.count(), is(3L)); assertThat(query.tenantIdIn(TENANT_ONE).count(), is(1L)); assertThat(query.tenantIdIn(TENANT_TWO).count(), is(1L)); assertThat(query.withoutTenantId().count(), is(1L)); }
@Test public void testDefinitionRetrieval_ByKey() { given().pathParam("key", MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY) .then().expect() .statusCode(Status.OK.getStatusCode()) .body("id", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID)) .body("key", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY)) .body("category", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_CATEGORY)) .body("name", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_NAME)) .body("description", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_DESCRIPTION)) .body("deploymentId", equalTo(MockProvider.EXAMPLE_DEPLOYMENT_ID)) .body("version", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_VERSION)) .body("resource", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_RESOURCE_NAME)) .body("diagram", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_DIAGRAM_RESOURCE_NAME)) .body("suspended", equalTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_IS_SUSPENDED)) .body("tenantId", nullValue()) .when().get(SINGLE_PROCESS_DEFINITION_BY_KEY_URL); verify(processDefinitionQueryMock).withoutTenantId(); verify(repositoryServiceMock).getProcessDefinition(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID); }
public void testQueryByLatestWithoutTenantId() { // deploy a second version without tenant id deployment(emptyProcess); ProcessDefinitionQuery query = repositoryService .createProcessDefinitionQuery() .processDefinitionKey(PROCESS_DEFINITION_KEY) .latestVersion() .withoutTenantId(); assertThat(query.count(), is(1L)); ProcessDefinition processDefinition = query.singleResult(); assertThat(processDefinition.getTenantId(), is(nullValue())); assertThat(processDefinition.getVersion(), is(2)); }
public void testQueryByKey() { ProcessDefinitionQuery query = repositoryService .createProcessDefinitionQuery() .processDefinitionKey(PROCESS_DEFINITION_KEY); // one definition for each tenant assertThat(query.count(), is(3L)); query = repositoryService .createProcessDefinitionQuery() .processDefinitionKey(PROCESS_DEFINITION_KEY) .withoutTenantId(); // one definition without tenant id assertThat(query.count(), is(1L)); query = repositoryService .createProcessDefinitionQuery() .processDefinitionKey(PROCESS_DEFINITION_KEY) .tenantIdIn(TENANT_ONE); // one definition for tenant one assertThat(query.count(), is(1L)); }
@Test public void suspendProcessDefinitionForNonTenant() { // given activated process definitions ProcessDefinitionQuery query = engineRule.getRepositoryService().createProcessDefinitionQuery(); assertThat(query.active().count(), is(3L)); assertThat(query.suspended().count(), is(0L)); engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .processDefinitionWithoutTenantId() .suspend(); assertThat(query.active().count(), is(2L)); assertThat(query.suspended().count(), is(1L)); assertThat(query.suspended().withoutTenantId().count(), is(1L)); }
@Test public void suspendProcessDefinitionWithAuthenticatedTenant() { // given activated process definitions ProcessDefinitionQuery query = engineRule.getRepositoryService().createProcessDefinitionQuery(); assertThat(query.active().count(), is(3L)); assertThat(query.suspended().count(), is(0L)); engineRule.getIdentityService().setAuthentication("user", null, Arrays.asList(TENANT_ONE)); engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .suspend(); engineRule.getIdentityService().clearAuthentication(); assertThat(query.active().count(), is(1L)); assertThat(query.suspended().count(), is(2L)); assertThat(query.active().tenantIdIn(TENANT_TWO).count(), is(1L)); assertThat(query.suspended().tenantIdIn(TENANT_ONE).count(), is(1L)); assertThat(query.suspended().withoutTenantId().count(), is(1L)); }
@Test public void testProcessDefinitionWithoutTenantId() { Response response = given() .queryParam("withoutTenantId", true) .then().expect() .statusCode(Status.OK.getStatusCode()) .when() .get(PROCESS_DEFINITION_QUERY_URL); verify(mockedQuery).withoutTenantId(); verify(mockedQuery).list(); String content = response.asString(); List<String> definitions = from(content).getList(""); assertThat(definitions).hasSize(1); String returnedTenantId1 = from(content).getString("[0].tenantId"); assertThat(returnedTenantId1).isEqualTo(null); }
@Test public void suspendProcessDefinitionNoAuthenticatedTenants() { // given activated process definitions ProcessDefinitionQuery query = engineRule.getRepositoryService().createProcessDefinitionQuery(); assertThat(query.active().count(), is(3L)); assertThat(query.suspended().count(), is(0L)); engineRule.getIdentityService().setAuthentication("user", null, null); engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .suspend(); engineRule.getIdentityService().clearAuthentication(); assertThat(query.active().count(), is(2L)); assertThat(query.suspended().count(), is(1L)); assertThat(query.suspended().withoutTenantId().count(), is(1L)); }
@Test public void delayedSuspendProcessDefinitionsForNonTenant() { // given activated process definitions engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .processDefinitionWithoutTenantId() .executionDate(tomorrow()) .suspend(); ProcessDefinitionQuery query = engineRule.getRepositoryService().createProcessDefinitionQuery(); assertThat(query.active().count(), is(3L)); assertThat(query.suspended().count(), is(0L)); // when execute the job to suspend the process definition Job job = engineRule.getManagementService().createJobQuery().timers().singleResult(); assertThat(job, is(notNullValue())); engineRule.getManagementService().executeJob(job.getId()); assertThat(query.active().count(), is(2L)); assertThat(query.suspended().count(), is(1L)); assertThat(query.suspended().withoutTenantId().count(), is(1L)); }
@Test public void activateProcessDefinitionForNonTenant() { // given suspend process definitions engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .suspend(); ProcessDefinitionQuery query = engineRule.getRepositoryService().createProcessDefinitionQuery(); assertThat(query.suspended().count(), is(3L)); assertThat(query.active().count(), is(0L)); engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .processDefinitionWithoutTenantId() .activate(); assertThat(query.suspended().count(), is(2L)); assertThat(query.active().count(), is(1L)); assertThat(query.active().withoutTenantId().count(), is(1L)); }
protected void prepareProcessInstances(String key, int daysInThePast, Integer historyTimeToLive, int instanceCount, String tenantId) { List<ProcessDefinition> processDefinitions = null; if (tenantId == null) { processDefinitions = repositoryService.createProcessDefinitionQuery().processDefinitionKey(key).withoutTenantId().list(); } else { processDefinitions = repositoryService.createProcessDefinitionQuery().processDefinitionKey(key).tenantIdIn(tenantId).list(); } assertEquals(1, processDefinitions.size()); repositoryService.updateProcessDefinitionHistoryTimeToLive(processDefinitions.get(0).getId(), historyTimeToLive); Date oldCurrentTime = ClockUtil.getCurrentTime(); ClockUtil.setCurrentTime(DateUtils.addDays(oldCurrentTime, daysInThePast)); List<String> processInstanceIds = new ArrayList<String>(); { for (int i = 0; i < instanceCount; i++) { String processInstanceId = null; if (tenantId == null) { processInstanceId = runtimeService.createProcessInstanceByKey(PROCESS_DEFINITION_KEY).processDefinitionWithoutTenantId().execute().getId(); } else { processInstanceId = runtimeService.createProcessInstanceByKey(PROCESS_DEFINITION_KEY).processDefinitionTenantId(tenantId).execute().getId(); } processInstanceIds.add(processInstanceId); } } runtimeService.deleteProcessInstances(processInstanceIds, null, true, true); ClockUtil.setCurrentTime(oldCurrentTime); }
@Test public void delayedActivateProcessDefinitionsForNonTenant() { // given suspended process definitions engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .suspend(); engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionKey(PROCESS_DEFINITION_KEY) .processDefinitionWithoutTenantId() .executionDate(tomorrow()) .activate(); ProcessDefinitionQuery query = engineRule.getRepositoryService().createProcessDefinitionQuery(); assertThat(query.suspended().count(), is(3L)); assertThat(query.active().count(), is(0L)); // when execute the job to activate the process definition Job job = engineRule.getManagementService().createJobQuery().timers().singleResult(); assertThat(job, is(notNullValue())); engineRule.getManagementService().executeJob(job.getId()); assertThat(query.suspended().count(), is(2L)); assertThat(query.active().count(), is(1L)); assertThat(query.active().withoutTenantId().count(), is(1L)); }
@Test public void suspendProcessDefinitionByIdIncludeInstancesFromAllTenants() { // given active process instances with tenant id of process definition without tenant id engineRule.getRuntimeService().createProcessInstanceByKey(PROCESS_DEFINITION_KEY).processDefinitionWithoutTenantId().execute(); ProcessDefinition processDefinition = engineRule.getRepositoryService() .createProcessDefinitionQuery() .withoutTenantId() .singleResult(); ProcessInstanceQuery query = engineRule.getRuntimeService().createProcessInstanceQuery().processDefinitionId(processDefinition.getId()); assertThat(query.active().count(), is(1L)); assertThat(query.active().tenantIdIn(TENANT_ONE).count(), is(1L)); assertThat(query.suspended().count(), is(0L)); // suspend all instances of process definition engineRule.getRepositoryService() .updateProcessDefinitionSuspensionState() .byProcessDefinitionId(processDefinition.getId()) .includeProcessInstances(true) .suspend(); assertThat(query.active().count(), is(0L)); assertThat(query.suspended().count(), is(1L)); assertThat(query.suspended().tenantIdIn(TENANT_ONE).count(), is(1L)); }
.withoutTenantId() .singleResult();