Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

Fix: Asset model value validation for array value types (#1898)

Eric Bariaux649e3fc0f5f0
diff --git a/model/build.gradle b/model/build.gradle
index 17ae611bf..7b4a4b796 100644
--- a/model/build.gradle
+++ b/model/build.gradle
@@ -35,6 +35,17 @@ dependencies {
api "com.fasterxml.uuid:java-uuid-generator:$uuidGeneratorVersion"
api "fr.neolegal:exp4j:$exp4jVersion"
+
+ dependencies {
+ testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+ testImplementation 'org.mockito:mockito-core:5.12.0'
+ testRuntimeOnly 'org.glassfish:jakarta.el:4.0.2'
+ testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+ }
+}
+
+test {
+ useJUnitPlatform()
}
base {
diff --git a/model/src/main/java/org/openremote/model/util/ValueUtil.java b/model/src/main/java/org/openremote/model/util/ValueUtil.java
index 88c8a05f9..a92e46445 100644
--- a/model/src/main/java/org/openremote/model/util/ValueUtil.java
+++ b/model/src/main/java/org/openremote/model/util/ValueUtil.java
@@ -971,12 +971,12 @@ public class ValueUtil {
boolean valid = true;
if (valueDescriptor != null && valueDescriptor.getConstraints() != null) {
- if (Arrays.stream(valueDescriptor.getConstraints()).map(constraint -> validateValueConstraint(context, constraintBuilderProvider, now, constraint, value)).anyMatch(constraintValid -> !constraintValid)) {
+ if (validateConstraints(valueDescriptor.getArrayDimensions(), valueDescriptor.getConstraints(), context, constraintBuilderProvider, now, value)) {
valid = false;
}
}
if (attributeDescriptor != null && attributeDescriptor.getConstraints() != null) {
- if (Arrays.stream(attributeDescriptor.getConstraints()).map(constraint -> validateValueConstraint(context, constraintBuilderProvider, now, constraint, value)).anyMatch(constraintValid -> !constraintValid)) {
+ if (validateConstraints(valueDescriptor.getArrayDimensions(), attributeDescriptor.getConstraints(), context, constraintBuilderProvider, now, value)) {
valid = false;
}
}
@@ -997,6 +997,15 @@ public class ValueUtil {
return valid;
}
+ // TODO: as we recurse, we don't change the path, the error will always be reported on the attribute, not on a specific array index, can we live with that ?
+ private static boolean validateConstraints(Integer dimensions, ValueConstraint[] constraints, ConstraintValidatorContext context, ConstraintViolationPathProvider constraintBuilderProvider, Instant now, Object value) {
+ if (dimensions == null || dimensions == 0 || value == null) {
+ return Arrays.stream(constraints).map(constraint -> validateValueConstraint(context, constraintBuilderProvider, now, constraint, value)).anyMatch(constraintValid -> !constraintValid);
+ } else {
+ return Arrays.stream((Object[])value).anyMatch(v -> validateConstraints(dimensions - 1, constraints, context, constraintBuilderProvider, now, v));
+ }
+ }
+
public static boolean validateValueConstraint(ConstraintValidatorContext context, ConstraintViolationPathProvider constraintViolationPathProvider, Instant now, ValueConstraint valueConstraint, Object value) {
if (!valueConstraint.evaluate(value, now)) {
if (context instanceof HibernateConstraintValidatorContext hibernateContext) {
diff --git a/model/src/test/java/org/openremote/model/value/ValueUtilTest.java b/model/src/test/java/org/openremote/model/value/ValueUtilTest.java
new file mode 100644
index 000000000..fc636a44f
--- /dev/null
+++ b/model/src/test/java/org/openremote/model/value/ValueUtilTest.java
@@ -0,0 +1,208 @@
+package org.openremote.model.value;
+
+import jakarta.validation.ConstraintValidatorContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.openremote.model.attribute.Attribute;
+import org.openremote.model.util.ValueUtil;
+
+import java.time.Instant;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ValueUtilTest {
+
+ ConstraintValidatorContext context;
+ ConstraintValidatorContext.ConstraintViolationBuilder builder;
+ ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext node1;
+ ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext node2;
+ ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext containerBuilder;
+ ConstraintValidatorContext.ConstraintViolationBuilder.NodeContextBuilder containerBuilder2;
+ ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderDefinedContext containerBuilder3;
+
+ @BeforeEach
+ void setup() {
+ context = mock(ConstraintValidatorContext.class);
+ builder = mock(ConstraintValidatorContext.ConstraintViolationBuilder.class);
+ node1 = mock(ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext.class);
+ node2 = mock(ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext.class);
+ containerBuilder = mock(ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderCustomizableContext.class);
+ containerBuilder2 = mock(ConstraintValidatorContext.ConstraintViolationBuilder.NodeContextBuilder.class);
+ containerBuilder3 = mock(ConstraintValidatorContext.ConstraintViolationBuilder.NodeBuilderDefinedContext.class);
+
+ when(context.buildConstraintViolationWithTemplate(anyString()))
+ .thenReturn(builder);
+
+ when(builder.addPropertyNode("attributes"))
+ .thenReturn(node1);
+
+ when(node1.addPropertyNode("value"))
+ .thenReturn(node2);
+
+ when(node2.inContainer(Map.class, 1))
+ .thenReturn(containerBuilder);
+
+ when(containerBuilder.inIterable())
+ .thenReturn(containerBuilder2);
+
+ when(containerBuilder2.atKey(any()))
+ .thenReturn(containerBuilder3);
+ }
+
+ @Test
+ public void validatePositiveInteger() {
+ AttributeDescriptor<Integer> attributeDescriptor = new AttributeDescriptor<>("positiveNumber", ValueType.POSITIVE_INTEGER);
+
+ Attribute<Integer> attribute = new Attribute<>(attributeDescriptor);
+ attribute.setValue(1);
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertTrue(valid);
+ }
+
+ @Test
+ public void validatePositiveIntegerEmptyValue() {
+ AttributeDescriptor<Integer> attributeDescriptor = new AttributeDescriptor<>("positiveNumber", ValueType.POSITIVE_INTEGER);
+
+ Attribute<Integer> attribute = new Attribute<>(attributeDescriptor);
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertTrue(valid);
+ }
+
+ @Test
+ public void validatePositiveIntegerFalse() {
+ AttributeDescriptor<Integer> attributeDescriptor = new AttributeDescriptor<>("positiveNumber", ValueType.POSITIVE_INTEGER);
+
+ Attribute<Integer> attribute = new Attribute<>(attributeDescriptor);
+ attribute.setValue(-1);
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertFalse(valid);
+ }
+
+ @Test
+ public void validateArrayOfPositiveIntegers() {
+ AttributeDescriptor<Integer[]> attributeDescriptor = new AttributeDescriptor<>("arrayOfPositiveNumbers", ValueType.POSITIVE_INTEGER.asArray());
+
+ Attribute<Integer[]> attribute = new Attribute<>(attributeDescriptor);
+ attribute.setValue(new Integer[]{1, 2});
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertTrue(valid);
+ }
+
+ @Test
+ public void validateArrayOfPositiveIntegersEmptyValue() {
+ AttributeDescriptor<Integer[]> attributeDescriptor = new AttributeDescriptor<>("arrayOfPositiveNumbers", ValueType.POSITIVE_INTEGER.asArray());
+
+ Attribute<Integer[]> attribute = new Attribute<>(attributeDescriptor);
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertTrue(valid);
+ }
+
+ @Test
+ public void validateArrayOfPositiveIntegersFalse() {
+ AttributeDescriptor<Integer[]> attributeDescriptor = new AttributeDescriptor<>("arrayOfPositiveNumbers", ValueType.POSITIVE_INTEGER.asArray());
+
+ Attribute<Integer[]> attribute = new Attribute<>(attributeDescriptor);
+ attribute.setValue(new Integer[]{1, -2});
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertFalse(valid);
+ }
+
+ @Test
+ public void validateArrayOfArrayOfPositiveIntegers() {
+ AttributeDescriptor<Integer[][]> attributeDescriptor = new AttributeDescriptor<>("arrayOfArrayOfPositiveNumbers", ValueType.POSITIVE_INTEGER.asArray().asArray());
+
+ Attribute<Integer[][]> attribute = new Attribute<>(attributeDescriptor);
+ attribute.setValue(new Integer[][]{{1, 2},{5, 2}});
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertTrue(valid);
+ }
+
+ @Test
+ public void validateArrayOfArrayOfPositiveIntegersFalse() {
+ AttributeDescriptor<Integer[][]> attributeDescriptor = new AttributeDescriptor<>("arrayOfArrayOfPositiveNumbers", ValueType.POSITIVE_INTEGER.asArray().asArray());
+
+ Attribute<Integer[][]> attribute = new Attribute<>(attributeDescriptor);
+ attribute.setValue(new Integer[][]{{1, 2},{-5, 2}});
+
+ ValueUtil.ConstraintViolationPathProvider pathProvider = (constraintViolationBuilder) ->
+ constraintViolationBuilder
+ .addPropertyNode("attributes")
+ .addPropertyNode("value")
+ .inContainer(Map.class, 1)
+ .inIterable().atKey(attribute.getName());
+
+ Boolean valid = ValueUtil.validateValue(attributeDescriptor, attributeDescriptor.getType(), attribute, Instant.now(), context, pathProvider, attribute.getValue().orElse(null));
+
+ assertFalse(valid);
+ }
+
+}