private void setUpRuntimeData(CaseDefinition mockCaseDefinition) { repositoryServiceMock = mock(RepositoryService.class); when(processEngine.getRepositoryService()).thenReturn(repositoryServiceMock); when(repositoryServiceMock.getCaseDefinition(eq(MockProvider.EXAMPLE_CASE_DEFINITION_ID))).thenReturn(mockCaseDefinition); when(repositoryServiceMock.getCaseModel(eq(MockProvider.EXAMPLE_CASE_DEFINITION_ID))).thenReturn(createMockCaseDefinitionCmmnXml()); caseDefinitionQueryMock = mock(CaseDefinitionQuery.class); when(caseDefinitionQueryMock.caseDefinitionKey(MockProvider.EXAMPLE_CASE_DEFINITION_KEY)).thenReturn(caseDefinitionQueryMock); when(caseDefinitionQueryMock.tenantIdIn(anyString())).thenReturn(caseDefinitionQueryMock); when(caseDefinitionQueryMock.withoutTenantId()).thenReturn(caseDefinitionQueryMock); when(caseDefinitionQueryMock.latestVersion()).thenReturn(caseDefinitionQueryMock); when(caseDefinitionQueryMock.singleResult()).thenReturn(mockCaseDefinition); when(caseDefinitionQueryMock.list()).thenReturn(Collections.singletonList(mockCaseDefinition)); when(repositoryServiceMock.createCaseDefinitionQuery()).thenReturn(caseDefinitionQueryMock); }
public void testQueryByLatestWithTenantIds() { // deploy a second version for tenant one deploymentForTenant(TENANT_ONE, CMMN); CaseDefinitionQuery query = repositoryService .createCaseDefinitionQuery() .caseDefinitionKey(CASE_DEFINITION_KEY) .latestVersion() .tenantIdIn(TENANT_ONE, TENANT_TWO); // one definition for each tenant assertThat(query.count(), is(2L)); Map<String, CaseDefinition> caseDefinitionsForTenant = getCaseDefinitionsForTenant(query.list()); assertThat(caseDefinitionsForTenant.get(TENANT_ONE).getVersion(), is(2)); assertThat(caseDefinitionsForTenant.get(TENANT_TWO).getVersion(), is(1)); }
@Override protected void applyFilters(CaseDefinitionQuery query) { if (caseDefinitionId != null) { query.caseDefinitionId(caseDefinitionId); query.caseDefinitionIdIn(caseDefinitionIdIn.toArray(new String[caseDefinitionIdIn.size()])); query.caseDefinitionCategory(category); query.caseDefinitionCategoryLike(categoryLike); query.caseDefinitionName(name); query.caseDefinitionNameLike(nameLike); query.deploymentId(deploymentId); query.caseDefinitionKey(key); query.caseDefinitionKeyLike(keyLike); query.caseDefinitionResourceName(resourceName); query.caseDefinitionResourceNameLike(resourceNameLike); query.caseDefinitionVersion(version); query.latestVersion(); query.tenantIdIn(tenantIds.toArray(new String[tenantIds.size()]));
protected List<HalResource<?>> resolveNotCachedLinks(String[] linkedIds, ProcessEngine processEngine) { RepositoryService repositoryService = processEngine.getRepositoryService(); List<CaseDefinition> caseDefinitions = repositoryService.createCaseDefinitionQuery() .caseDefinitionIdIn(linkedIds) .listPage(0, linkedIds.length); List<HalResource<?>> resolved = new ArrayList<HalResource<?>>(); for (CaseDefinition caseDefinition : caseDefinitions) { resolved.add(HalCaseDefinition.fromCaseDefinition(caseDefinition, processEngine)); } return resolved; }
public long countDefinitionsByKey(String definitionKey) { return repositoryService.createCaseDefinitionQuery().caseDefinitionKey(definitionKey).count(); }
@Test public void testAdditionalParameters() { Map<String, String> queryParameters = getCompleteQueryParameters(); given() .queryParams(queryParameters) .expect() .statusCode(Status.OK.getStatusCode()) .when() .get(CASE_DEFINITION_QUERY_URL); // assert query invocation verify(mockedQuery).caseDefinitionId(queryParameters.get("caseDefinitionId")); verify(mockedQuery).caseDefinitionCategory(queryParameters.get("category")); verify(mockedQuery).caseDefinitionCategoryLike(queryParameters.get("categoryLike")); verify(mockedQuery).caseDefinitionName(queryParameters.get("name")); verify(mockedQuery).caseDefinitionNameLike(queryParameters.get("nameLike")); verify(mockedQuery).deploymentId(queryParameters.get("deploymentId")); verify(mockedQuery).caseDefinitionKey(queryParameters.get("key")); verify(mockedQuery).caseDefinitionKeyLike(queryParameters.get("keyLike")); verify(mockedQuery).caseDefinitionVersion(Integer.parseInt(queryParameters.get("version"))); verify(mockedQuery).latestVersion(); verify(mockedQuery).caseDefinitionResourceName(queryParameters.get("resourceName")); verify(mockedQuery).caseDefinitionResourceNameLike(queryParameters.get("resourceNameLike")); verify(mockedQuery).list(); }
.caseDefinitionId("test") .latestVersion() .list(); fail(); } catch (NotValidException e) { .caseDefinitionName("test") .latestVersion() .list(); fail(); } catch (NotValidException e) { .caseDefinitionNameLike("test") .latestVersion() .list(); fail(); } catch (NotValidException e) { .caseDefinitionVersion(1) .latestVersion() .list(); fail(); } catch (NotValidException e) { .deploymentId("test") .latestVersion() .list(); fail(); } catch (NotValidException e) {
public void testQueryByLatestWithoutTenantId() { // deploy a second version without tenant id deployment(CMMN); CaseDefinitionQuery query = repositoryService .createCaseDefinitionQuery() .caseDefinitionKey(CASE_DEFINITION_KEY) .latestVersion() .withoutTenantId(); assertThat(query.count(), is(1L)); CaseDefinition cDefinition = query.singleResult(); assertThat(cDefinition.getTenantId(), is(nullValue())); assertThat(cDefinition.getVersion(), is(2)); }
.caseDefinitionId(caseInstance.getCaseDefinitionId()) .singleResult();
protected CaseInstance createCaseInstance(String businessKey) { String caseDefinitionKey = repositoryService. createCaseDefinitionQuery() .singleResult() .getKey(); return createCaseInstanceByKey(caseDefinitionKey, businessKey); }
protected void createCaseInstance(String tenantId) { String caseDefinitionId = null; CaseDefinitionQuery caseDefinitionQuery = repositoryService.createCaseDefinitionQuery().caseDefinitionKey("oneTaskCase"); if (tenantId == null) { caseDefinitionId = caseDefinitionQuery.withoutTenantId().singleResult().getId(); } else { caseDefinitionId = caseDefinitionQuery.tenantIdIn(tenantId).singleResult().getId(); } caseService.withCaseDefinition(caseDefinitionId).create(); }
protected CaseDefinition getCaseDefinition(String key) { return repositoryService.createCaseDefinitionQuery().caseDefinitionKey(key).singleResult(); }
public void testStartCaseInstanceWithLatestBindingDifferentVersion() { deploymentForTenant(TENANT_ONE, CMMN_LATEST_WITH_MANUAL_ACTIVATION, CMMN_CASE); deploymentForTenant(TENANT_TWO, CMMN_LATEST_WITH_MANUAL_ACTIVATION, CMMN_CASE); deploymentForTenant(TENANT_TWO, CMMN_CASE); createCaseInstance("caseTaskCase", TENANT_ONE); createCaseInstance("caseTaskCase", TENANT_TWO); CaseInstanceQuery query = caseService.createCaseInstanceQuery().caseDefinitionKey("oneTaskCase"); assertThat(query.tenantIdIn(TENANT_ONE).count(), is(1L)); CaseDefinition latestCaseDefinitionTenantTwo = repositoryService.createCaseDefinitionQuery(). caseDefinitionKey("oneTaskCase").tenantIdIn(TENANT_TWO).latestVersion().singleResult(); query = caseService.createCaseInstanceQuery().caseDefinitionId(latestCaseDefinitionTenantTwo.getId()); assertThat(query.count(), is(1L)); }
@Override public String getLatestDefinitionIdByKey(RepositoryService repositoryService, String key) { return repositoryService.createCaseDefinitionQuery().caseDefinitionKey(key).latestVersion().singleResult().getId(); }
public void testQueryByCaseDefinitionIds() { // empty list assertTrue(repositoryService.createCaseDefinitionQuery().caseDefinitionIdIn("a", "b").list().isEmpty()); // collect all ids List<CaseDefinition> caseDefinitions = repositoryService.createCaseDefinitionQuery().list(); // no point of the test if the caseDefinitions is empty assertFalse(caseDefinitions.isEmpty()); List<String> ids = new ArrayList<String>(); for (CaseDefinition caseDefinition : caseDefinitions) { ids.add(caseDefinition.getId()); } caseDefinitions = repositoryService.createCaseDefinitionQuery() .caseDefinitionIdIn(ids.toArray(new String[ids.size()])) .list(); assertEquals(ids.size(), caseDefinitions.size()); for (CaseDefinition caseDefinition : caseDefinitions) { if (!ids.contains(caseDefinition.getId())) { fail("Expected to find case definition "+ caseDefinition); } } assertEquals(0, repositoryService.createCaseDefinitionQuery() .caseDefinitionIdIn(ids.toArray(new String[ids.size()])) .caseDefinitionId("nonExistent") .count()); }
public void testQueryAuthenticatedTenant() { identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE)); CaseDefinitionQuery query = repositoryService.createCaseDefinitionQuery(); assertThat(query.count(), is(2L)); assertThat(query.tenantIdIn(TENANT_ONE).count(), is(1L)); assertThat(query.tenantIdIn(TENANT_TWO).count(), is(0L)); assertThat(query.tenantIdIn(TENANT_ONE, TENANT_TWO).includeCaseDefinitionsWithoutTenantId().count(), is(2L)); }
protected void verifyCmmnResourceDeployed(String resourcePath) { String deploymentId = processEngine .getRepositoryService() .createDeployment() .addClasspathResource(resourcePath) .deploy() .getId(); // there should be one deployment RepositoryService repositoryService = processEngine.getRepositoryService(); DeploymentQuery deploymentQuery = repositoryService.createDeploymentQuery(); assertEquals(1, deploymentQuery.count()); // there should be one case definition CaseDefinitionQuery query = processEngine.getRepositoryService().createCaseDefinitionQuery(); assertEquals(1, query.count()); CaseDefinition caseDefinition = query.singleResult(); assertEquals("Case_1", caseDefinition.getKey()); processEngine.getRepositoryService().deleteDeployment(deploymentId); }
public void testQueryAuthenticatedTenants() { identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO)); CaseDefinitionQuery query = repositoryService.createCaseDefinitionQuery(); 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)); }
when(sampleCaseDefinitionQuery.listPage(0, 1)).thenReturn(mockCaseDefinitions); when(sampleCaseDefinitionQuery.caseDefinitionIdIn(MockProvider.EXAMPLE_CASE_DEFINITION_ID)).thenReturn(sampleCaseDefinitionQuery); when(sampleCaseDefinitionQuery.count()).thenReturn(1l); when(processEngine.getRepositoryService().createCaseDefinitionQuery()).thenReturn(sampleCaseDefinitionQuery);
public void testQueryByTenantId() { CaseDefinitionQuery query = repositoryService .createCaseDefinitionQuery() .tenantIdIn(TENANT_ONE); assertThat(query.count(), is(1L)); query = repositoryService. createCaseDefinitionQuery() .tenantIdIn(TENANT_TWO); assertThat(query.count(), is(1L)); }