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); }
@Test public void queryByKey() { DecisionDefinitionQuery query = repositoryService.createDecisionDefinitionQuery(); // decision one query .decisionDefinitionKey("one"); verifyQueryResults(query, 2); // decision two query .decisionDefinitionKey("two"); verifyQueryResults(query, 1); }
public DecisionDefinition call() throws Exception { return repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(decisionDefinitionKey) .singleResult(); } });
@Test public void queryByInvalidKey() { DecisionDefinitionQuery query = repositoryService.createDecisionDefinitionQuery(); query .decisionDefinitionKey("invalid"); verifyQueryResults(query, 0); try { query.decisionDefinitionKey(null); fail(); } catch (NotValidException e) { // Expected exception } }
public long countDefinitionsByKey(String definitionKey) { return repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(definitionKey).count(); }
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 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)); }
@Test public void testNonExistingDecisionDefinitionRetrieval_ByKeyAndTenantId() { String nonExistingKey = "aNonExistingDefinitionKey"; String nonExistingTenantId = "aNonExistingTenantId"; when(repositoryServiceMock.createDecisionDefinitionQuery().decisionDefinitionKey(nonExistingKey)).thenReturn(decisionDefinitionQueryMock); when(decisionDefinitionQueryMock.singleResult()).thenReturn(null); given() .pathParam("key", nonExistingKey) .pathParam("tenant-id", nonExistingTenantId) .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 + " and tenant-id: " + nonExistingTenantId)) .when().get(SINGLE_DECISION_DEFINITION_BY_KEY_AND_TENANT_ID_URL); }
@Override public String getLatestDefinitionIdByKey(RepositoryService repositoryService, String key) { return repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(key).latestVersion().singleResult().getId(); }
@Test public void queryByLatest() { DecisionDefinitionQuery query = repositoryService.createDecisionDefinitionQuery(); query .latestVersion(); verifyQueryResults(query, 3); query .decisionDefinitionKey("one") .latestVersion(); verifyQueryResults(query, 1); query .decisionDefinitionKey("two").latestVersion(); verifyQueryResults(query, 1); }
public void testQueryByLatestWithoutTenantId() { // deploy a second version without tenant id deployment(DMN); DecisionDefinitionQuery query = repositoryService .createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY) .latestVersion() .withoutTenantId(); assertThat(query.count(), is(1L)); DecisionDefinition decisionDefinition = query.singleResult(); assertThat(decisionDefinition.getTenantId(), is(nullValue())); assertThat(decisionDefinition.getVersion(), is(2)); }
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); }
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)); }
@Test public void testDeployProcessArchive() { Assert.assertNotNull(processEngine); RepositoryService repositoryService = processEngine.getRepositoryService(); long count = repositoryService.createDecisionDefinitionQuery() .decisionDefinitionKey("testDeployProcessArchiveWithDmn") .count(); Assert.assertEquals(1, count); }
@Test public void testReportCompact() { // given List<DecisionDefinition> decisionDefinitions = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(DECISION_DEFINITION_KEY).list(); assertEquals(1, decisionDefinitions.size()); // assume List<CleanableHistoricDecisionInstanceReportResult> resultWithZeros = historyService.createCleanableHistoricDecisionInstanceReport().list(); assertEquals(1, resultWithZeros.size()); assertEquals(0, resultWithZeros.get(0).getFinishedDecisionInstanceCount()); // when long resultCountWithoutZeros = historyService.createCleanableHistoricDecisionInstanceReport().compact().count(); // then assertEquals(0, resultCountWithoutZeros); }
@Deployment(resources = { DECISION_PROCESS, DECISION_SINGLE_OUTPUT_DMN }) public void testQueryByDecisionDefinitionId() { String decisionDefinitionId = repositoryService.createDecisionDefinitionQuery() .decisionDefinitionKey(DECISION_DEFINITION_KEY).singleResult().getId(); startProcessInstanceAndEvaluateDecision(); HistoricDecisionInstanceQuery query = historyService.createHistoricDecisionInstanceQuery(); assertThat(query.decisionDefinitionId(decisionDefinitionId).count(), is(1L)); assertThat(query.decisionDefinitionId("other id").count(), is(0L)); }
@Deployment(resources = DECISION_SINGLE_OUTPUT_DMN) public void testDecisionDefinitionPassedToHistoryLevel() { RecordHistoryLevel historyLevel = (RecordHistoryLevel) processEngineConfiguration.getHistoryLevel(); DecisionDefinition decisionDefinition = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey("testDecision").singleResult(); VariableMap variables = Variables.createVariables().putValue("input1", true); decisionService.evaluateDecisionTableByKey("testDecision", variables); List<RecordHistoryLevel.ProducedHistoryEvent> producedHistoryEvents = historyLevel.getProducedHistoryEvents(); assertEquals(1, producedHistoryEvents.size()); RecordHistoryLevel.ProducedHistoryEvent producedHistoryEvent = producedHistoryEvents.get(0); assertEquals(HistoryEventTypes.DMN_DECISION_EVALUATE, producedHistoryEvent.eventType); DecisionDefinition entity = (DecisionDefinition) producedHistoryEvent.entity; assertNotNull(entity); assertEquals(decisionDefinition.getId(), entity.getId()); }
protected void prepareDecisionInstances(String key, int daysInThePast, Integer historyTimeToLive, int instanceCount) { List<DecisionDefinition> decisionDefinitions = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(key).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++) { engineRule.getDecisionService().evaluateDecisionByKey(key).variables(variables).evaluate(); } ClockUtil.setCurrentTime(oldCurrentTime); }
private void prepareHistoricDecisions(int instanceCount) { Date oldCurrentTime = ClockUtil.getCurrentTime(); List<DecisionDefinition> decisionDefinitions = engineRule.getRepositoryService().createDecisionDefinitionQuery().decisionDefinitionKey("decision").list(); assertEquals(1, decisionDefinitions.size()); engineRule.getRepositoryService().updateDecisionDefinitionHistoryTimeToLive(decisionDefinitions.get(0).getId(), 5); ClockUtil.setCurrentTime(DateUtils.addDays(new Date(), -6)); for (int i = 0; i < instanceCount; i++) { engineRule.getDecisionService().evaluateDecisionByKey("decision").variables(Variables.createVariables().putValue("status", "silver").putValue("sum", 723)) .evaluate(); } ClockUtil.setCurrentTime(oldCurrentTime); } }