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 testFailQueryByTenantIdNull() { try { repositoryService.createDecisionDefinitionQuery() .tenantIdIn((String) null); fail("expected exception"); } catch (NullValueException e) { } }
public void testQueryByTenantId() { DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_ONE); assertThat(query.count(), is(1L)); query = repositoryService. createDecisionDefinitionQuery() .tenantIdIn(TENANT_TWO); assertThat(query.count(), is(1L)); }
public void testQueryByTenantIds() { DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_ONE, TENANT_TWO); assertThat(query.count(), is(2L)); }
public void testQueryByNonExistingTenantId() { DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .tenantIdIn("nonExisting"); assertThat(query.count(), is(0L)); }
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)); }
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)); }
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 testQueryAuthenticatedTenants() { identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO)); DecisionDefinitionQuery query = repositoryService.createDecisionDefinitionQuery(); 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)); }
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()); } }
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()); } }
public void testQueryByTenantIdsIncludeDefinitionsWithoutTenantId() { DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_ONE) .includeDecisionDefinitionsWithoutTenantId(); assertThat(query.count(), is(2L)); query = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_TWO) .includeDecisionDefinitionsWithoutTenantId(); assertThat(query.count(), is(2L)); query = repositoryService .createDecisionDefinitionQuery() .tenantIdIn(TENANT_ONE, TENANT_TWO) .includeDecisionDefinitionsWithoutTenantId(); assertThat(query.count(), is(3L)); }
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 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)); }
protected void evaluateDecisionInstanceForTenant(String tenant) { String decisionDefinitionId = repositoryService.createDecisionDefinitionQuery() .tenantIdIn(tenant) .singleResult() .getId(); VariableMap variables = Variables.createVariables().putValue("status", "bronze"); decisionService.evaluateDecisionTableById(decisionDefinitionId, variables); }
public void testQueryByLatestWithTenantId() { // deploy a second version for tenant one deploymentForTenant(TENANT_ONE, DMN); DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .latestVersion() .tenantIdIn(TENANT_ONE); assertThat(query.count(), is(1L)); DecisionDefinition decisionDefinition = query.singleResult(); assertThat(decisionDefinition.getTenantId(), is(TENANT_ONE)); assertThat(decisionDefinition.getVersion(), is(2)); query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .latestVersion() .tenantIdIn(TENANT_TWO); assertThat(query.count(), is(1L)); decisionDefinition = query.singleResult(); assertThat(decisionDefinition.getTenantId(), is(TENANT_TWO)); assertThat(decisionDefinition.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)); }
protected String evaluateDecisionTable(String tenantId) { String decisionDefinitionId; if (tenantId == null) { decisionDefinitionId = repositoryService.createDecisionDefinitionQuery().singleResult().getId(); } else { decisionDefinitionId = repositoryService.createDecisionDefinitionQuery() .tenantIdIn(tenantId).singleResult().getId(); } VariableMap variables = Variables.createVariables().putValue("status", "bronze"); decisionService.evaluateDecisionTableById(decisionDefinitionId, variables); return decisionDefinitionId; }
@Test public void testDecisionDefinitionTenantIdIncludeDefinitionsWithoutTenantid() { List<DecisionDefinition> decisionDefinitions = Arrays.asList( MockProvider.mockDecisionDefinition().tenantId(null).build(), MockProvider.mockDecisionDefinition().tenantId(MockProvider.EXAMPLE_TENANT_ID).build()); mockedQuery = createMockDecisionDefinitionQuery(decisionDefinitions); Response response = given() .queryParam("tenantIdIn", MockProvider.EXAMPLE_TENANT_ID) .queryParam("includeDecisionDefinitionsWithoutTenantId", true) .then().expect() .statusCode(Status.OK.getStatusCode()) .when() .get(DECISION_DEFINITION_QUERY_URL); verify(mockedQuery).tenantIdIn(MockProvider.EXAMPLE_TENANT_ID); verify(mockedQuery).includeDecisionDefinitionsWithoutTenantId(); verify(mockedQuery).list(); String content = response.asString(); List<String> definitions = from(content).getList(""); assertThat(definitions).hasSize(2); String returnedTenantId1 = from(content).getString("[0].tenantId"); String returnedTenantId2 = from(content).getString("[1].tenantId"); assertThat(returnedTenantId1).isEqualTo(null); assertThat(returnedTenantId2).isEqualTo(MockProvider.EXAMPLE_TENANT_ID); }
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); }