@Test public void testAdditionalParameters() { Map<String, String> queryParameters = getCompleteQueryParameters(); given() .queryParams(queryParameters) .expect() .statusCode(Status.OK.getStatusCode()) .when() .get(DECISION_DEFINITION_QUERY_URL); // assert query invocation verify(mockedQuery).decisionDefinitionId(queryParameters.get("decisionDefinitionId")); verify(mockedQuery).decisionDefinitionCategory(queryParameters.get("category")); verify(mockedQuery).decisionDefinitionCategoryLike(queryParameters.get("categoryLike")); verify(mockedQuery).decisionDefinitionName(queryParameters.get("name")); verify(mockedQuery).decisionDefinitionNameLike(queryParameters.get("nameLike")); verify(mockedQuery).deploymentId(queryParameters.get("deploymentId")); verify(mockedQuery).decisionDefinitionKey(queryParameters.get("key")); verify(mockedQuery).decisionDefinitionKeyLike(queryParameters.get("keyLike")); verify(mockedQuery).decisionDefinitionVersion(Integer.parseInt(queryParameters.get("version"))); verify(mockedQuery).latestVersion(); verify(mockedQuery).decisionDefinitionResourceName(queryParameters.get("resourceName")); verify(mockedQuery).decisionDefinitionResourceNameLike(queryParameters.get("resourceNameLike")); verify(mockedQuery).decisionRequirementsDefinitionId(queryParameters.get("decisionRequirementsDefinitionId")); verify(mockedQuery).decisionRequirementsDefinitionKey(queryParameters.get("decisionRequirementsDefinitionKey")); verify(mockedQuery).versionTag(queryParameters.get("versionTag")); verify(mockedQuery).versionTagLike(queryParameters.get("versionTagLike")); verify(mockedQuery).withoutDecisionRequirementsDefinition(); verify(mockedQuery).list(); }
public void testQueryByLatestWithTenantIds() { // deploy a second version for tenant one deploymentForTenant(TENANT_ONE, DMN); DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .latestVersion() .tenantIdIn(TENANT_ONE, TENANT_TWO) .orderByTenantId() .asc(); // one definition for each tenant assertThat(query.count(), is(2L)); Map<String, DecisionDefinition> decisionDefinitionsForTenant = getDecisionDefinitionsForTenant(query.list()); assertThat(decisionDefinitionsForTenant.get(TENANT_ONE).getVersion(), is(2)); assertThat(decisionDefinitionsForTenant.get(TENANT_TWO).getVersion(), is(1)); }
@Override protected void applyFilters(DecisionDefinitionQuery query) { if (decisionDefinitionId != null) { query.decisionDefinitionId(decisionDefinitionId); query.decisionDefinitionIdIn(decisionDefinitionIdIn.toArray(new String[decisionDefinitionIdIn.size()])); query.decisionDefinitionCategory(category); query.decisionDefinitionCategoryLike(categoryLike); query.decisionDefinitionName(name); query.decisionDefinitionNameLike(nameLike); query.deploymentId(deploymentId); query.decisionDefinitionKey(key); query.decisionDefinitionKeyLike(keyLike); query.decisionDefinitionResourceName(resourceName); query.decisionDefinitionResourceNameLike(resourceNameLike); query.decisionDefinitionVersion(version); query.latestVersion(); query.decisionRequirementsDefinitionId(decisionRequirementsDefinitionId);
public DecisionDefinitionResource getDecisionDefinitionByKeyAndTenantId(String decisionDefinitionKey, String tenantId) { DecisionDefinition decisionDefinition = getProcessEngine() .getRepositoryService() .createDecisionDefinitionQuery() .decisionDefinitionKey(decisionDefinitionKey) .tenantIdIn(tenantId) .latestVersion() .singleResult(); if (decisionDefinition == null) { String errorMessage = String.format("No matching decision definition with key: %s and tenant-id: %s", decisionDefinitionKey, tenantId); throw new RestException(Status.NOT_FOUND, errorMessage); } else { return getDecisionDefinitionById(decisionDefinition.getId()); } }
@Override public DecisionDefinitionResource getDecisionDefinitionByKey(String decisionDefinitionKey) { DecisionDefinition decisionDefinition = getProcessEngine() .getRepositoryService() .createDecisionDefinitionQuery() .decisionDefinitionKey(decisionDefinitionKey) .withoutTenantId() .latestVersion() .singleResult(); if (decisionDefinition == null) { String errorMessage = String.format("No matching decision definition with key: %s and no tenant-id", decisionDefinitionKey); throw new RestException(Status.NOT_FOUND, errorMessage); } else { return getDecisionDefinitionById(decisionDefinition.getId()); } }
.decisionDefinitionId("test") .latestVersion() .list(); fail(); } catch (NotValidException e) { .decisionDefinitionName("test") .latestVersion() .list(); fail(); } catch (NotValidException e) { .decisionDefinitionNameLike("test") .latestVersion() .list(); fail(); } catch (NotValidException e) { .decisionDefinitionVersion(1) .latestVersion() .list(); fail(); } catch (NotValidException e) { .deploymentId("test") .latestVersion() .list(); fail(); } catch (NotValidException e) {
private void setUpRuntimeData(DecisionDefinition mockDecisionDefinition) { repositoryServiceMock = mock(RepositoryService.class); when(processEngine.getRepositoryService()).thenReturn(repositoryServiceMock); when(repositoryServiceMock.getDecisionDefinition(eq(MockProvider.EXAMPLE_DECISION_DEFINITION_ID))).thenReturn(mockDecisionDefinition); when(repositoryServiceMock.getDecisionModel(eq(MockProvider.EXAMPLE_DECISION_DEFINITION_ID))).thenReturn(createMockDecisionDefinitionDmnXml()); decisionDefinitionQueryMock = mock(DecisionDefinitionQuery.class); when(decisionDefinitionQueryMock.decisionDefinitionKey(MockProvider.EXAMPLE_DECISION_DEFINITION_KEY)).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.tenantIdIn(anyString())).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.withoutTenantId()).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.latestVersion()).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.singleResult()).thenReturn(mockDecisionDefinition); when(decisionDefinitionQueryMock.list()).thenReturn(Collections.singletonList(mockDecisionDefinition)); when(repositoryServiceMock.createDecisionDefinitionQuery()).thenReturn(decisionDefinitionQueryMock); }
public void testQueryByLatestWithTenantIdsIncludeDefinitionsWithoutTenantId() { // deploy a second version without tenant id deployment(DMN); // deploy a third version for tenant one deploymentForTenant(TENANT_ONE, DMN); deploymentForTenant(TENANT_ONE, DMN); DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .latestVersion() .tenantIdIn(TENANT_ONE, TENANT_TWO) .includeDecisionDefinitionsWithoutTenantId(); assertThat(query.count(), is(3L)); Map<String, DecisionDefinition> decisionDefinitionsForTenant = getDecisionDefinitionsForTenant(query.list()); assertThat(decisionDefinitionsForTenant.get(TENANT_ONE).getVersion(), is(3)); assertThat(decisionDefinitionsForTenant.get(TENANT_TWO).getVersion(), is(1)); assertThat(decisionDefinitionsForTenant.get(null).getVersion(), is(2)); }
public void testQueryByLatestNoTenantIdSet() { // deploy a second version for tenant one deploymentForTenant(TENANT_ONE, DMN); DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .latestVersion(); // one definition for each tenant assertThat(query.count(), is(3L)); Map<String, DecisionDefinition> decisionDefinitionsForTenant = getDecisionDefinitionsForTenant(query.list()); assertThat(decisionDefinitionsForTenant.get(TENANT_ONE).getVersion(), is(2)); assertThat(decisionDefinitionsForTenant.get(TENANT_TWO).getVersion(), is(1)); assertThat(decisionDefinitionsForTenant.get(null).getVersion(), is(1)); }
public void testQueryByKey() { DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY); // one definition for each tenant assertThat(query.count(), is(3L)); query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .withoutTenantId(); // one definition without tenant id assertThat(query.count(), is(1L)); query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .tenantIdIn(TENANT_ONE); // one definition for tenant one assertThat(query.count(), is(1L)); }
public DecisionDefinition call() throws Exception { return repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(decisionDefinitionKey) .singleResult(); } });
@Test public void testNonExistingDecisionDefinitionRetrieval_ByKey() { String nonExistingKey = "aNonExistingDefinitionKey"; when(repositoryServiceMock.createDecisionDefinitionQuery().decisionDefinitionKey(nonExistingKey)).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.latestVersion()).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.singleResult()).thenReturn(null); when(decisionDefinitionQueryMock.list()).thenReturn(Collections.<DecisionDefinition> emptyList()); given() .pathParam("key", nonExistingKey) .then() .expect() .statusCode(Status.NOT_FOUND.getStatusCode()).contentType(ContentType.JSON) .body("type", is(RestException.class.getSimpleName())) .body("message", containsString("No matching decision definition with key: " + nonExistingKey)) .when() .get(SINGLE_DECISION_DEFINITION_BY_KEY_URL); }
public void testQueryAuthenticatedTenant() { identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE)); DecisionDefinitionQuery query = repositoryService.createDecisionDefinitionQuery(); 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).includeDecisionDefinitionsWithoutTenantId().count(), is(2L)); }
private void removeHistoryTimeToLive() { List<ProcessDefinition> processDefinitions = repositoryService.createProcessDefinitionQuery().processDefinitionKey(ONE_TASK_PROCESS).list(); assertEquals(1, processDefinitions.size()); repositoryService.updateProcessDefinitionHistoryTimeToLive(processDefinitions.get(0).getId(), null); final List<DecisionDefinition> decisionDefinitions = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(DECISION).list(); assertEquals(1, decisionDefinitions.size()); repositoryService.updateDecisionDefinitionHistoryTimeToLive(decisionDefinitions.get(0).getId(), null); final List<CaseDefinition> caseDefinitions = repositoryService.createCaseDefinitionQuery().caseDefinitionKey(ONE_TASK_CASE).list(); assertEquals(1, caseDefinitions.size()); repositoryService.updateCaseDefinitionHistoryTimeToLive(caseDefinitions.get(0).getId(), null); }
protected void prepareDecisionInstances(String key, int daysInThePast, Integer historyTimeToLive, int instanceCount, String tenantId) { List<DecisionDefinition> decisionDefinitions = null; if (tenantId != null) { decisionDefinitions = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(key).tenantIdIn(tenantId).list(); } else { decisionDefinitions = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(key).withoutTenantId().list(); } assertEquals(1, decisionDefinitions.size()); repositoryService.updateDecisionDefinitionHistoryTimeToLive(decisionDefinitions.get(0).getId(), historyTimeToLive); Date oldCurrentTime = ClockUtil.getCurrentTime(); ClockUtil.setCurrentTime(DateUtils.addDays(oldCurrentTime, daysInThePast)); Map<String, Object> variables = Variables.createVariables().putValue("status", "silver").putValue("sum", 723); for (int i = 0; i < instanceCount; i++) { if (tenantId != null) { engineRule.getDecisionService().evaluateDecisionByKey(key).decisionDefinitionTenantId(tenantId).variables(variables).evaluate(); } else { engineRule.getDecisionService().evaluateDecisionByKey(key).decisionDefinitionWithoutTenantId().variables(variables).evaluate(); } } ClockUtil.setCurrentTime(oldCurrentTime); }
public void testQuerySortingDesc() { // exclude definitions without tenant id because of database-specific ordering List<DecisionDefinition> decisionDefinitions = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_ONE, TENANT_TWO) .orderByTenantId() .desc() .list(); assertThat(decisionDefinitions.size(), is(2)); assertThat(decisionDefinitions.get(0).getTenantId(), is(TENANT_TWO)); assertThat(decisionDefinitions.get(1).getTenantId(), is(TENANT_ONE)); }
public void testQuerySortingAsc() { // exclude definitions without tenant id because of database-specific ordering List<DecisionDefinition> decisionDefinitions = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_ONE, TENANT_TWO) .orderByTenantId() .asc() .list(); assertThat(decisionDefinitions.size(), is(2)); assertThat(decisionDefinitions.get(0).getTenantId(), is(TENANT_ONE)); assertThat(decisionDefinitions.get(1).getTenantId(), is(TENANT_TWO)); }
@Deployment(resources = { "org/camunda/bpm/engine/test/api/repository/versionTag.dmn", "org/camunda/bpm/engine/test/api/repository/versionTagHigher.dmn" }) @Test public void testQueryOrderByVersionTag() { List<DecisionDefinition> decisionDefinitionList = repositoryService .createDecisionDefinitionQuery() .versionTagLike("1%") .orderByVersionTag() .asc() .list(); assertEquals("1.1.0", decisionDefinitionList.get(1).getVersionTag()); }
@Test public void queryByDecisionDefinitionIds() { // empty list assertTrue(repositoryService.createDecisionDefinitionQuery().decisionDefinitionIdIn("a", "b").list().isEmpty()); // collect all ids List<DecisionDefinition> decisionDefinitions = repositoryService.createDecisionDefinitionQuery().list(); List<String> ids = new ArrayList<String>(); for (DecisionDefinition decisionDefinition : decisionDefinitions) { ids.add(decisionDefinition.getId()); } decisionDefinitions = repositoryService.createDecisionDefinitionQuery() .decisionDefinitionIdIn(ids.toArray(new String[ids.size()])) .list(); assertEquals(ids.size(), decisionDefinitions.size()); for (DecisionDefinition decisionDefinition : decisionDefinitions) { if (!ids.contains(decisionDefinition.getId())) { fail("Expected to find decision definition "+ decisionDefinition); } } }
private DecisionDefinitionQuery createMockDecisionDefinitionQuery(List<DecisionDefinition> mockedDefinitions) { DecisionDefinitionQuery sampleDefinitionsQuery = mock(DecisionDefinitionQuery.class); when(sampleDefinitionsQuery.list()).thenReturn(mockedDefinitions); when(sampleDefinitionsQuery.count()).thenReturn((long) mockedDefinitions.size()); when(processEngine.getRepositoryService().createDecisionDefinitionQuery()).thenReturn(sampleDefinitionsQuery); return sampleDefinitionsQuery; }