100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps
Java asset-managementbuildingdashboarddataplatformdevice-managementedge-computingenergyenergy-managementenergy-monitorfleet-managementfleet-telematicsiotiot-applicationiot-platformmodbusmqttmqtt-brokerota-updaterules-enginesmartcity
Fix: Asset model value validation for array value types (#1898)
Eric Bariaux649e3fc0f5f0
diff --git a/model/build.gradle b/model/build.gradleindex 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.javaindex 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.javanew file mode 100644index 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);+ }++}