@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testNoOutputValue() {
DmnDecisionTableResult decisionResult = evaluateWithMatchingRules(NO_OUTPUT_VALUE);
assertThat(decisionResult).hasSize(1);
assertNoOutputValue(decisionResult.getFirstResult());
}
@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testNoResult() {
DmnDecisionTableResult results = evaluateWithMatchingRules();
assertThat(results).isEmpty();
assertThat(results.getFirstResult()).isNull();
assertThat(results.getSingleResult()).isNull();
}
@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testSingleResult() {
DmnDecisionTableResult results = evaluateWithMatchingRules(SINGLE_OUTPUT_VALUE);
assertThat(results).hasSize(1);
assertSingleOutputValue(results.get(0));
assertSingleOutputValue(results.getFirstResult());
assertSingleOutputValue(results.getSingleResult());
}
@Test
@DecisionResource
public void testSingleOutputNoName() {
DmnDecisionTableResult decisionResult = evaluateDecisionTable();
assertThat(decisionResult).hasSize(1);
assertThat(decisionResult.getFirstResult()).hasSize(1);
assertThat(decisionResult.getFirstResult().getSingleEntry()).isEqualTo("outputValue");
assertThat(decisionResult.getFirstResult().get(null)).isEqualTo("outputValue");
}
@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testValueMap() {
DmnDecisionTableResult decisionResult = evaluateWithMatchingRules(MULTIPLE_OUTPUT_VALUES);
DmnDecisionRuleResult ruleResult = decisionResult.getSingleResult();
assertThat(ruleResult).hasSize(2);
Map<String, Object> entryMap = ruleResult.getEntryMap();
assertThat(entryMap).hasSize(2);
assertThat(entryMap).containsEntry("firstOutput", "multipleValues1");
assertThat(entryMap).containsEntry("secondOutput", "multipleValues2");
}
@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testCollectOutputValues() {
DmnDecisionTableResult decisionResult =
evaluateWithMatchingRules(NO_OUTPUT_VALUE, SINGLE_OUTPUT_VALUE, MULTIPLE_OUTPUT_VALUES);
assertThat(decisionResult).hasSize(3);
List<String> entryValues = decisionResult.collectEntries("firstOutput");
assertThat(entryValues).containsExactly("singleValue", "multipleValues1");
entryValues = decisionResult.collectEntries("secondOutput");
assertThat(entryValues).containsExactly("multipleValues2");
}
@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testOutputList() {
DmnDecisionTableResult decisionResult =
evaluateWithMatchingRules(SINGLE_OUTPUT_VALUE, MULTIPLE_OUTPUT_VALUES);
List<Map<String, Object>> entryMapList = decisionResult.getResultList();
assertThat(entryMapList).hasSize(2);
Map<String, Object> firstResult = entryMapList.get(0);
assertThat(firstResult).hasSize(1);
assertThat(firstResult).containsEntry("firstOutput", "singleValue");
Map<String, Object> secondResult = entryMapList.get(1);
assertThat(secondResult).hasSize(2);
assertThat(secondResult).containsEntry("firstOutput", "multipleValues1");
assertThat(secondResult).containsEntry("secondOutput", "multipleValues2");
}
@Test
@DecisionResource(resource = RESULT_TEST_WITH_TYPES_DMN)
public void testSingleOutputTypedValue() {
DmnDecisionTableResult decisionResult = evaluateWithMatchingRules(SINGLE_OUTPUT_VALUE);
assertThat(decisionResult).hasSize(1);
DmnDecisionRuleResult ruleResult = decisionResult.getFirstResult();
TypedValue typedValue = ruleResult.getEntryTyped("firstOutput");
assertThat(typedValue).isEqualTo(Variables.stringValue("singleValue"));
typedValue = ruleResult.getEntryTyped("secondOutput");
assertThat(typedValue).isNull();
typedValue = ruleResult.getFirstEntryTyped();
assertThat(typedValue).isEqualTo(Variables.stringValue("singleValue"));
typedValue = ruleResult.getSingleEntryTyped();
assertThat(typedValue).isEqualTo(Variables.stringValue("singleValue"));
}
@Test
@DecisionResource(resource = RESULT_TEST_DMN)
public void testMultipleResults() {
DmnDecisionTableResult decisionResult =
evaluateWithMatchingRules(NO_OUTPUT_VALUE, SINGLE_OUTPUT_VALUE, MULTIPLE_OUTPUT_VALUES);
assertThat(decisionResult).hasSize(3);
DmnDecisionRuleResult ruleResult = decisionResult.get(0);
assertNoOutputValue(ruleResult);
ruleResult = decisionResult.get(1);
assertSingleOutputValue(ruleResult);
ruleResult = decisionResult.get(2);
assertMultipleOutputValues(ruleResult);
ruleResult = decisionResult.getFirstResult();
assertNoOutputValue(ruleResult);
try {
decisionResult.getSingleResult();
failBecauseExceptionWasNotThrown(DmnDecisionResultException.class);
} catch (DmnDecisionResultException e) {
assertThat(e)
.hasMessageStartingWith("DMN-01008")
.hasMessageContaining("singleValue")
.hasMessageContaining("multipleValues1")
.hasMessageContaining("multipleValues2");
}
}