This is an automated email from the ASF dual-hosted git repository.
yamer pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie-drools.git
The following commit(s) were added to refs/heads/main by this push:
new 5c430aaaa3 [incubator-kie-issues#1100] Fix oas-generation. Add tests
(#5858)
5c430aaaa3 is described below
commit 5c430aaaa36f973d3573477962aee26943ed947a
Author: Gabriele Cardosi <[email protected]>
AuthorDate: Mon Apr 22 17:05:06 2024 +0200
[incubator-kie-issues#1100] Fix oas-generation. Add tests (#5858)
Co-authored-by: Gabriele-Cardosi <[email protected]>
---
.../org/kie/dmn/openapi/impl/DMNTypeSchemas.java | 13 +-
.../org/kie/dmn/openapi/impl/FEELSchemaEnum.java | 73 ++++++--
.../org/kie/dmn/openapi/FEELSchemaEnumTest.java | 60 ------
.../kie/dmn/openapi/impl/FEELSchemaEnumTest.java | 206 +++++++++++++++++++++
4 files changed, 269 insertions(+), 83 deletions(-)
diff --git
a/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/DMNTypeSchemas.java
b/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/DMNTypeSchemas.java
index 9470626605..92a04692a8 100644
---
a/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/DMNTypeSchemas.java
+++
b/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/DMNTypeSchemas.java
@@ -18,8 +18,10 @@
*/
package org.kie.dmn.openapi.impl;
+import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -72,8 +74,7 @@ public class DMNTypeSchemas {
return FEELBuiltinTypeSchemas.from(t);
}
if (typesIndex.contains(t)) {
- Schema schema =
OASFactory.createObject(Schema.class).ref(namingPolicy.getRef(t));
- return schema;
+ return
OASFactory.createObject(Schema.class).ref(namingPolicy.getRef(t));
}
throw new UnsupportedOperationException();
}
@@ -131,7 +132,7 @@ public class DMNTypeSchemas {
parseSimpleType(DMNOASConstants.X_DMN_ALLOWED_VALUES, t, schema,
t.getAllowedValuesFEEL(), t.getAllowedValues());
}
if (t.getTypeConstraint() != null && !t.getTypeConstraint().isEmpty())
{
- parseSimpleType(DMNOASConstants.X_DMN_TYPE_CONSTRAINTS, t, schema,
t.getTypeConstraintFEEL(), t.getAllowedValues());
+ parseSimpleType(DMNOASConstants.X_DMN_TYPE_CONSTRAINTS, t, schema,
t.getTypeConstraintFEEL(), t.getTypeConstraint());
}
schema = nestAsItemIfCollection(schema, t);
schema.addExtension(X_DMN_TYPE, getDMNTypeSchemaXDMNTYPEdescr(t));
@@ -142,7 +143,9 @@ public class DMNTypeSchemas {
private void parseSimpleType(String schemaString, SimpleTypeImpl t, Schema
schema, List<UnaryTest> feelUnaryTests, List<DMNUnaryTest> dmnUnaryTests) {
schema.addExtension(schemaString,
feelUnaryTests.stream().map(UnaryTest::toString).collect(Collectors.joining(",
")));
if (DMNTypeUtils.getFEELBuiltInType(ancestor(t)) ==
BuiltInType.NUMBER) {
- FEELSchemaEnum.parseNumbersIntoSchema(schema, dmnUnaryTests);
+ FEELSchemaEnum.parseRangeableValuesIntoSchema(schema,
dmnUnaryTests, Number.class);
+ } else if (DMNTypeUtils.getFEELBuiltInType(ancestor(t)) ==
BuiltInType.DATE) {
+ FEELSchemaEnum.parseRangeableValuesIntoSchema(schema,
dmnUnaryTests, LocalDate.class);
} else {
FEELSchemaEnum.parseValuesIntoSchema(schema, dmnUnaryTests);
}
@@ -154,7 +157,7 @@ public class DMNTypeSchemas {
for (Entry<String, DMNType> fkv : ct.getFields().entrySet()) {
schema.addProperty(fkv.getKey(),
refOrBuiltinSchema(fkv.getValue()));
}
- if (isIOSetForInputScope(ct) && ct.getFields().size() > 0) {
+ if (isIOSetForInputScope(ct) && !ct.getFields().isEmpty()) {
schema.required(new ArrayList<>(ct.getFields().keySet()));
}
} else {
diff --git
a/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/FEELSchemaEnum.java
b/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/FEELSchemaEnum.java
index 30e2cb5813..ccdb377508 100644
---
a/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/FEELSchemaEnum.java
+++
b/kie-dmn/kie-dmn-openapi/src/main/java/org/kie/dmn/openapi/impl/FEELSchemaEnum.java
@@ -18,10 +18,6 @@
*/
package org.kie.dmn.openapi.impl;
-import java.math.BigDecimal;
-import java.util.List;
-import java.util.stream.Collectors;
-
import org.eclipse.microprofile.openapi.models.media.Schema;
import org.kie.dmn.api.core.DMNUnaryTest;
import org.kie.dmn.feel.FEEL;
@@ -32,24 +28,35 @@ import org.kie.dmn.feel.runtime.impl.RangeImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
public class FEELSchemaEnum {
private static final Logger LOG =
LoggerFactory.getLogger(FEELSchemaEnum.class);
- public static void parseValuesIntoSchema(Schema schema, List<DMNUnaryTest>
list) {
- List<Object> expectLiterals = evaluateUnaryTests(list);
+ public static void parseValuesIntoSchema(Schema schema, List<DMNUnaryTest>
unaryTests) {
+ List<Object> expectLiterals = evaluateUnaryTests(unaryTests);
+ try {
+ checkEvaluatedUnaryTestsForTypeConsistency(expectLiterals);
+ } catch (IllegalArgumentException e) {
+ LOG.warn("Unable to parse generic value into the JSON Schema for
enumeration");
+ return;
+ }
if (expectLiterals.contains(null)) {
schema.setNullable(true);
}
- boolean allLiterals = expectLiterals.stream().allMatch(o -> o == null
|| o instanceof String || o instanceof Number || o instanceof Boolean);
+ boolean allLiterals = !expectLiterals.isEmpty() &&
expectLiterals.stream().allMatch(o -> o == null || o instanceof String || o
instanceof Number || o instanceof Boolean);
if (allLiterals) {
schema.enumeration(expectLiterals);
} else {
LOG.warn("Unable to parse generic value into the JSON Schema for
enumeration");
}
}
-
- public static void parseNumbersIntoSchema(Schema schema,
List<DMNUnaryTest> list) {
+
+ public static void parseRangeableValuesIntoSchema(Schema schema,
List<DMNUnaryTest> list, Class<?> expectedType) {
List<Object> uts = evaluateUnaryTests(list); // we leverage the
property of the *base* FEEL grammar(non visited by ASTVisitor, only the
ParseTree->AST Visitor) that `>x` is a Range
boolean allowNull = uts.remove(null);
if (allowNull) {
@@ -67,13 +74,13 @@ public class FEELSchemaEnum {
schema.exclusiveMaximum(range.getHighBoundary() ==
RangeBoundary.OPEN);
}
}
- } else if (uts.stream().allMatch(o -> o instanceof Number)) {
+ } else if (uts.stream().allMatch(expectedType::isInstance)) {
if (allowNull) {
uts.add(null);
}
schema.enumeration(uts);
} else {
- LOG.warn("Unable to parse number value into the JSON Schema for
enumeration");
+ LOG.warn("Unable to parse {} value into the JSON Schema for
enumeration", expectedType);
}
}
@@ -99,13 +106,43 @@ public class FEELSchemaEnum {
return consistent ? result : null;
}
- private static List<Object> evaluateUnaryTests(List<DMNUnaryTest> list) {
- FEEL SimpleFEEL = FEEL.newInstance();
- List<Object> utEvaluated = list.stream().map(UnaryTestImpl.class::cast)
- .map(UnaryTestImpl::toString)
- .map(SimpleFEEL::evaluate)
- .collect(Collectors.toList());
- return utEvaluated;
+ static List<Object> evaluateUnaryTests(List<DMNUnaryTest> list) {
+ FEEL feelInstance = FEEL.newInstance();
+ List<Object> toReturn = list.stream()
+ .map(UnaryTestImpl.class::cast)
+ .map(UnaryTestImpl::toString)
+ .filter(str -> !str.contains("?")) // We have to exclude
"TEST" expressions, because they can't be evaluated without a context and their
return is meaningless
+ .map(feelInstance::evaluate)
+ .collect(Collectors.toList());
+ checkEvaluatedUnaryTestsForNull(toReturn);
+ return toReturn;
+ }
+
+ /**
+ * Method used to verify if the given <code>List</code> contains at most
one <code>null</code>,
+ * since those should be put in the "enum" attribute
+ *
+ * @param toCheck
+ */
+ static void checkEvaluatedUnaryTestsForNull(List<Object> toCheck) {
+ if (toCheck.stream().filter(Objects::isNull).toList().size() > 1) {
+ throw new IllegalArgumentException("More then one object is null,
only one allowed at maximum");
+ }
+ }
+
+ /**
+ * Method used to verify if the given <code>List</code> contains the same
type of <code>Object</code>s,
+ * since those should be put in the "enum" attribute
+ *
+ * @param toCheck
+ */
+ static void checkEvaluatedUnaryTestsForTypeConsistency(List<Object>
toCheck) {
+ if (toCheck.stream().filter(Objects::nonNull)
+ .map(Object::getClass)
+ .collect(Collectors.toUnmodifiableSet())
+ .size() > 1) {
+ throw new IllegalArgumentException("Different types of objects,
only one allowed");
+ }
}
private FEELSchemaEnum() {
diff --git
a/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/FEELSchemaEnumTest.java
b/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/FEELSchemaEnumTest.java
deleted file mode 100644
index 6cfc24287b..0000000000
---
a/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/FEELSchemaEnumTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.kie.dmn.openapi;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.junit.Test;
-import org.kie.dmn.feel.runtime.Range;
-import org.kie.dmn.feel.runtime.Range.RangeBoundary;
-import org.kie.dmn.feel.runtime.impl.RangeImpl;
-import org.kie.dmn.openapi.impl.FEELSchemaEnum;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class FEELSchemaEnumTest extends BaseDMNOASTest {
-
- @Test
- public void testBasic() {
- List<Range> list = new ArrayList<>();
- list.add(new RangeImpl(RangeBoundary.CLOSED, 0, null,
RangeBoundary.CLOSED));
- list.add(new RangeImpl(RangeBoundary.CLOSED, null, 100,
RangeBoundary.CLOSED));
- Range result = FEELSchemaEnum.consolidateRanges(list);
- assertThat(result).isNotNull().isEqualTo(new
RangeImpl(RangeBoundary.CLOSED, 0, 100, RangeBoundary.CLOSED));
- }
-
- @Test
- public void testInvalidRepeatedLB() {
- List<Range> list = new ArrayList<>();
- list.add(new RangeImpl(RangeBoundary.CLOSED, 0, null,
RangeBoundary.CLOSED));
- list.add(new RangeImpl(RangeBoundary.CLOSED, 0, 100,
RangeBoundary.CLOSED));
- Range result = FEELSchemaEnum.consolidateRanges(list);
- assertThat(result).isNull();
- }
-
- @Test
- public void testInvalidRepeatedUB() {
- List<Range> list = new ArrayList<>();
- list.add(new RangeImpl(RangeBoundary.CLOSED, null, 50,
RangeBoundary.CLOSED));
- list.add(new RangeImpl(RangeBoundary.CLOSED, null, 100,
RangeBoundary.CLOSED));
- Range result = FEELSchemaEnum.consolidateRanges(list);
- assertThat(result).isNull();
- }
-}
diff --git
a/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/impl/FEELSchemaEnumTest.java
b/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/impl/FEELSchemaEnumTest.java
new file mode 100644
index 0000000000..70704d4452
--- /dev/null
+++
b/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/impl/FEELSchemaEnumTest.java
@@ -0,0 +1,206 @@
+package org.kie.dmn.openapi.impl;
+
+
+import org.eclipse.microprofile.openapi.OASFactory;
+import org.eclipse.microprofile.openapi.models.media.Schema;
+import org.junit.Test;
+import org.kie.dmn.api.core.DMNUnaryTest;
+import org.kie.dmn.feel.FEEL;
+import org.kie.dmn.feel.runtime.Range;
+import org.kie.dmn.feel.runtime.impl.RangeImpl;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static
org.kie.dmn.openapi.impl.FEELSchemaEnum.checkEvaluatedUnaryTestsForNull;
+import static
org.kie.dmn.openapi.impl.FEELSchemaEnum.checkEvaluatedUnaryTestsForTypeConsistency;
+import static org.kie.dmn.openapi.impl.FEELSchemaEnum.evaluateUnaryTests;
+import static
org.kie.dmn.openapi.impl.FEELSchemaEnum.parseRangeableValuesIntoSchema;
+import static org.kie.dmn.openapi.impl.FEELSchemaEnum.parseValuesIntoSchema;
+
+public class FEELSchemaEnumTest {
+
+ private static final FEEL feel = FEEL.newInstance();
+
+ @Test
+ public void testParseValuesIntoSchemaWithoutNull() {
+ Schema toPopulate = OASFactory.createObject(Schema.class);
+ List<String> expectedStrings = Arrays.asList("ONE", "TWO");
+ List<Object> toEnum = expectedStrings.stream().map(toMap ->
String.format("\"%s\"", toMap)).collect(Collectors.toUnmodifiableList());
+ String expression = String.join(",", toEnum.stream().map(toMap ->
String.format("%s", toMap.toString())).toList());
+ expression += ", count (?) > 1";
+ List<DMNUnaryTest> unaryTests =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ parseValuesIntoSchema(toPopulate, unaryTests);
+ assertNull(toPopulate.getNullable());
+ assertNotNull(toPopulate.getEnumeration());
+ assertEquals(expectedStrings.size(),
toPopulate.getEnumeration().size());
+ expectedStrings.forEach(expectedString ->
assertTrue(toPopulate.getEnumeration().contains(expectedString)));
+ }
+
+ @Test
+ public void testParseValuesIntoSchemaWithNull() {
+ Schema toPopulate = OASFactory.createObject(Schema.class);
+ List<String> expectedStrings = Arrays.asList(null, "ONE", "TWO");
+ List<Object> toEnum = expectedStrings.stream().map(toFormat ->
toFormat == null ? "null": String.format("\"%s\"",
toFormat)).collect(Collectors.toUnmodifiableList());
+ String expression = String.join(",", toEnum.stream().map(toMap ->
String.format("%s", toMap.toString())).toList());
+ List<DMNUnaryTest> unaryTests =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ parseValuesIntoSchema(toPopulate, unaryTests);
+ assertTrue(toPopulate.getNullable());
+ assertNotNull(toPopulate.getEnumeration());
+ assertEquals(expectedStrings.size(),
toPopulate.getEnumeration().size());
+
expectedStrings.stream().filter(Objects::nonNull).forEach(expectedString ->
assertTrue(toPopulate.getEnumeration().contains(expectedString)));
+ }
+
+ @Test
+ public void testParseRangeableValuesIntoSchemaNumberWithoutNull() {
+ Schema toPopulate = OASFactory.createObject(Schema.class);
+ List<Number> expectedNumbers = Arrays.asList(1, 2);
+ String expression = String.join(",",
expectedNumbers.stream().map(toMap -> String.format("%s", toMap)).toList());
+ List<DMNUnaryTest> unaryTests =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ parseRangeableValuesIntoSchema(toPopulate, unaryTests, Number.class);
+ assertNull(toPopulate.getNullable());
+ assertNotNull(toPopulate.getEnumeration());
+ assertEquals(expectedNumbers.size(),
toPopulate.getEnumeration().size());
+ List<Object> expected = Arrays.asList(BigDecimal.valueOf(1),
BigDecimal.valueOf(2));
+ expected.forEach(expectedNumber ->
assertTrue(toPopulate.getEnumeration().contains(expectedNumber)));
+ }
+
+ @Test
+ public void testParseRangeableValuesNumberIntoSchemaWithNull() {
+ Schema toPopulate = OASFactory.createObject(Schema.class);
+ List<Number> expectedNumbers = Arrays.asList(null, 1, 2);
+ String expression = String.join(",",
expectedNumbers.stream().map(toMap -> String.format("%s", toMap)).toList());
+ List<DMNUnaryTest> unaryTests =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ parseRangeableValuesIntoSchema(toPopulate, unaryTests, Number.class);
+ assertTrue(toPopulate.getNullable());
+ assertNotNull(toPopulate.getEnumeration());
+ assertEquals(expectedNumbers.size(),
toPopulate.getEnumeration().size());
+ List<Object> expected = Arrays.asList(null, BigDecimal.valueOf(1),
BigDecimal.valueOf(2));
+ expected.stream().forEach(expectedNumber ->
assertTrue(toPopulate.getEnumeration().contains(expectedNumber)));
+ }
+
+ @Test
+ public void testParseRangeableValuesIntoSchemaLocalDateWithoutNull() {
+ Schema toPopulate = OASFactory.createObject(Schema.class);
+ List<LocalDate> expectedDates = Arrays.asList(LocalDate.of(2022, 1,
1), LocalDate.of(2024, 1, 1));
+ List<String> formattedDates = expectedDates.stream()
+ .map(toFormat -> String.format("@\"%s-0%s-0%s\"",
toFormat.getYear(), toFormat.getMonthValue(), toFormat.getDayOfMonth()))
+ .toList();
+ String expression = String.join(",", formattedDates.stream().map(toMap
-> String.format("%s", toMap)).toList());
+ List<DMNUnaryTest> unaryTests =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ parseRangeableValuesIntoSchema(toPopulate, unaryTests,
LocalDate.class);
+ assertNull(toPopulate.getNullable());
+ assertNotNull(toPopulate.getEnumeration());
+ assertEquals(expectedDates.size(), toPopulate.getEnumeration().size());
+ expectedDates.forEach(expectedDate ->
assertTrue(toPopulate.getEnumeration().contains(expectedDate)));
+ }
+
+ @Test
+ public void testParseRangeableValuesDateIntoSchemaWithNull() {
+ Schema toPopulate = OASFactory.createObject(Schema.class);
+ List<LocalDate> expectedDates = Arrays.asList(null, LocalDate.of(2022,
1, 1), LocalDate.of(2024, 1, 1));
+ List<String> formattedDates = expectedDates.stream()
+ .map(toFormat -> toFormat == null ? "null" :
String.format("@\"%s-0%s-0%s\"", toFormat.getYear(), toFormat.getMonthValue(),
toFormat.getDayOfMonth()))
+ .toList();
+ String expression = String.join(",", formattedDates.stream().map(toMap
-> String.format("%s", toMap)).toList());
+ List<DMNUnaryTest> unaryTests =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ parseRangeableValuesIntoSchema(toPopulate, unaryTests,
LocalDate.class);
+ assertTrue(toPopulate.getNullable());
+ assertNotNull(toPopulate.getEnumeration());
+ assertEquals(expectedDates.size(), toPopulate.getEnumeration().size());
+ expectedDates.forEach(expectedDate ->
assertTrue(toPopulate.getEnumeration().contains(expectedDate)));
+ }
+
+ @Test
+ public void testConsolidateRangesSucceed() {
+ Range lowRange = new RangeImpl(Range.RangeBoundary.CLOSED, 0, null,
Range.RangeBoundary.CLOSED);
+ Range highRange = new RangeImpl(Range.RangeBoundary.CLOSED, null, 100,
Range.RangeBoundary.CLOSED);
+ List<Range> list = Arrays.asList(lowRange, highRange);
+ Range result = FEELSchemaEnum.consolidateRanges(list);
+ assertThat(result).isNotNull().isEqualTo(new
RangeImpl(lowRange.getLowBoundary(), lowRange.getLowEndPoint(),
highRange.getHighEndPoint(), highRange.getHighBoundary()));
+ //
+ lowRange = new RangeImpl(Range.RangeBoundary.CLOSED,
LocalDate.of(2022, 1, 1), null, Range.RangeBoundary.CLOSED);
+ highRange = new RangeImpl(Range.RangeBoundary.CLOSED, null,
LocalDate.of(2024, 1, 1), Range.RangeBoundary.CLOSED);
+ list = Arrays.asList(lowRange, highRange);
+ result = FEELSchemaEnum.consolidateRanges(list);
+ assertThat(result).isNotNull().isEqualTo(new
RangeImpl(lowRange.getLowBoundary(), lowRange.getLowEndPoint(),
highRange.getHighEndPoint(), highRange.getHighBoundary()));
+ }
+
+ @Test
+ public void testConsolidateRangesInvalidRepeatedLB() {
+ List<Range> list = new ArrayList<>();
+ list.add(new RangeImpl(Range.RangeBoundary.CLOSED, 0, null,
Range.RangeBoundary.CLOSED));
+ list.add(new RangeImpl(Range.RangeBoundary.CLOSED, 0, 100,
Range.RangeBoundary.CLOSED));
+ Range result = FEELSchemaEnum.consolidateRanges(list);
+ assertThat(result).isNull();
+ }
+
+ @Test
+ public void testConsolidateRangesInvalidRepeatedUB() {
+ List<Range> list = new ArrayList<>();
+ list.add(new RangeImpl(Range.RangeBoundary.CLOSED, null, 50,
Range.RangeBoundary.CLOSED));
+ list.add(new RangeImpl(Range.RangeBoundary.CLOSED, null, 100,
Range.RangeBoundary.CLOSED));
+ Range result = FEELSchemaEnum.consolidateRanges(list);
+ assertThat(result).isNull();
+ }
+
+ @Test
+ public void testEvaluateUnaryTestsSucceed() {
+ List<Object> toEnum = Arrays.asList("\"a string\"", 3,
"@\"2024-01-01\"");
+ String expression = String.join(",", toEnum.stream().map(toMap ->
String.format("%s", toMap.toString())).toList());
+ expression += ", count (?) > 1";
+ List<DMNUnaryTest> toCheck =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ assertEquals(toEnum.size() + 1, toCheck.size());
+ List<Object> retrieved = evaluateUnaryTests(toCheck);
+ List<Object> expected = Arrays.asList("a string",
BigDecimal.valueOf(3), LocalDate.of(2024, 1, 1));
+ assertEquals(expected.size(), retrieved.size());
+ expected.forEach(expectedEntry -> assertTrue("Failing asserts for " +
expectedEntry, retrieved.stream().anyMatch(ret -> Objects.equals(expectedEntry,
ret))));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testEvaluateUnaryTestsFails() {
+ List<Object> toEnum = Arrays.asList(null, null, "@\"2024-01-01\"");
+ String expression = String.join(",", toEnum.stream().map(toMap ->
String.format("%s", toMap)).toList());
+ List<DMNUnaryTest> toCheck =
feel.evaluateUnaryTests(expression).stream().map(DMNUnaryTest.class::cast).toList();
+ assertEquals(toEnum.size(), toCheck.size());
+ evaluateUnaryTests(toCheck);
+ }
+
+ @Test
+ public void testCheckEvaluatedUnaryTestsForNullSucceed() {
+ List<Object> toCheck = new ArrayList<>(Arrays.asList("1", "2", "3"));
+ checkEvaluatedUnaryTestsForNull(toCheck);
+ toCheck.add(null);
+ checkEvaluatedUnaryTestsForNull(toCheck);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testCheckEvaluatedUnaryTestsForNullFails() {
+ List<Object> toCheck = new ArrayList<>(Arrays.asList("1", "2", "3"));
+ toCheck.add(null);
+ toCheck.add(null);
+ checkEvaluatedUnaryTestsForNull(toCheck);
+ }
+
+ @Test
+ public void testCheckEvaluatedUnaryTestsForTypeConsistencySucceed() {
+ List<Object> toCheck = Arrays.asList("1", "2", "3");
+ checkEvaluatedUnaryTestsForTypeConsistency(toCheck);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testCheckEvaluatedUnaryTestsForTypeConsistencyFails() {
+ List<Object> toCheck = Arrays.asList("1", "2", 3);
+ checkEvaluatedUnaryTestsForTypeConsistency(toCheck);
+ }
+}
\ No newline at end of file
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
