From 92b18f188105d5ba4b2c469cdfaedc7d2953d593 Mon Sep 17 00:00:00 2001 From: "andre.schmid" Date: Wed, 10 Aug 2022 14:50:08 +0100 Subject: Support TOSCA functions in Node Filters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds support to use tosca functions as value in the node property filters and substitution filters Change-Id: Id242691cc9ddd233245b58f052b9f0e2c7bbd66b Issue-ID: SDC-4128 Signed-off-by: André Schmid --- .../sdc/be/model/dto/FilterConstraintDtoTest.java | 101 +++++++++++++++ .../operations/NodeFilterOperationTest.java | 41 ++++-- .../AbstractPropertyConstraintTest.java | 1 + .../AbstractStringPropertyConstraintTest.java | 1 + .../be/ui/mapper/FilterConstraintMapperTest.java | 142 +++++++++++++++++++++ 5 files changed, 274 insertions(+), 12 deletions(-) create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/dto/FilterConstraintDtoTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/FilterConstraintMapperTest.java (limited to 'catalog-model/src/test') diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/dto/FilterConstraintDtoTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/dto/FilterConstraintDtoTest.java new file mode 100644 index 0000000000..e67fdc0f33 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/dto/FilterConstraintDtoTest.java @@ -0,0 +1,101 @@ +/* + * - + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Nordix Foundation. + * ================================================================================ + * Licensed 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. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.dto; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.junit.jupiter.api.Test; +import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.PropertySource; +import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType; + +class FilterConstraintDtoTest { + + @Test + void isCapabilityPropertyFilter() { + var filterConstraintDto = new FilterConstraintDto(); + assertFalse(filterConstraintDto.isCapabilityPropertyFilter()); + filterConstraintDto.setCapabilityName("aCapability"); + assertTrue(filterConstraintDto.isCapabilityPropertyFilter()); + } + + @Test + void readGetFunctionWithToscaGetFunctionInstanceAsValue() { + final var filterConstraintDto = new FilterConstraintDto(); + final var toscaGetFunction = new ToscaGetFunctionDataDefinition(); + toscaGetFunction.setFunctionType(ToscaGetFunctionType.GET_PROPERTY); + filterConstraintDto.setValue(toscaGetFunction); + final Optional readGetFunctionOpt = filterConstraintDto.getAsToscaGetFunction(); + assertTrue(readGetFunctionOpt.isPresent()); + assertEquals(toscaGetFunction, readGetFunctionOpt.get()); + } + + @Test + void readGetFunctionWithInvalidGetFunctionValue() { + final var filterConstraintDto = new FilterConstraintDto(); + filterConstraintDto.setValue("not a ToscaGetFunctionDataDefinition"); + final Optional readGetFunctionOpt = filterConstraintDto.getAsToscaGetFunction(); + assertTrue(readGetFunctionOpt.isEmpty()); + } + + @Test + void readGetFunctionWithGetFunctionValueAsMap() { + //given + final List propertyPathFromSource = List.of("input", "path"); + final String propertyUniqueId = "propertyUniqueIdValue"; + final String propertyName = "propertyNameValue"; + final String sourceUniqueId = "sourceUniqueIdValue"; + final String sourceName = "sourceNameValue"; + final Map toscaGetFunctionAsMap = Map.of( + "propertyUniqueId", propertyUniqueId, + "propertyName", propertyName, + "propertySource", PropertySource.SELF.getName(), + "sourceUniqueId", sourceUniqueId, + "sourceName", sourceName, + "functionType", ToscaGetFunctionType.GET_INPUT.getFunctionName(), + "propertyPathFromSource", propertyPathFromSource + ); + + final var filterConstraintDto = new FilterConstraintDto(); + filterConstraintDto.setValue(toscaGetFunctionAsMap); + //when + final Optional readGetFunctionOpt = filterConstraintDto.getAsToscaGetFunction(); + //then + assertTrue(readGetFunctionOpt.isPresent()); + final ToscaGetFunctionDataDefinition toscaGetFunctionDataDefinition = readGetFunctionOpt.get(); + assertEquals(toscaGetFunctionDataDefinition.getPropertyUniqueId(), propertyUniqueId); + assertEquals(toscaGetFunctionDataDefinition.getPropertyName(), propertyName); + assertEquals(toscaGetFunctionDataDefinition.getPropertySource(), PropertySource.SELF); + assertEquals(toscaGetFunctionDataDefinition.getSourceUniqueId(), sourceUniqueId); + assertEquals(toscaGetFunctionDataDefinition.getSourceName(), sourceName); + assertEquals(toscaGetFunctionDataDefinition.getFunctionType(), ToscaGetFunctionType.GET_INPUT); + assertEquals(toscaGetFunctionDataDefinition.getPropertyPathFromSource().size(), 2); + assertEquals(toscaGetFunctionDataDefinition.getPropertyPathFromSource().get(0), propertyPathFromSource.get(0)); + assertEquals(toscaGetFunctionDataDefinition.getPropertyPathFromSource().get(1), propertyPathFromSource.get(1)); + } + +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperationTest.java index 0cbba25e04..bd16016ad9 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperationTest.java @@ -21,6 +21,8 @@ package org.openecomp.sdc.be.model.jsonjanusgraph.operations; import fj.data.Either; +import java.util.List; +import java.util.Map; import org.janusgraph.core.JanusGraphVertex; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -33,7 +35,11 @@ import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; +import org.openecomp.sdc.be.datatypes.enums.FilterValueType; +import org.openecomp.sdc.be.datatypes.enums.PropertyFilterTargetType; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import java.util.Arrays; @@ -66,19 +72,30 @@ class NodeFilterOperationTest { nodeFilterDataDefinition.setName("new node filter name"); String prop1 = "property1"; String prop2 = "property2"; - RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition(); - requirementNodeFilterPropertyDataDefinition.setName("Name1"); - requirementNodeFilterPropertyDataDefinition - .setConstraints(Arrays.asList("mem_size:\n" + " equal: { get_property : [" + prop1 + ", size]}\n")); - RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition2 = new RequirementNodeFilterPropertyDataDefinition(); - requirementNodeFilterPropertyDataDefinition2.setName("Name2"); - requirementNodeFilterPropertyDataDefinition2 - .setConstraints(Arrays.asList("mem_size:\n {equal: { get_property : [SELF, " + prop2 + "]}}\n")); + final var propertyFilterDataDefinition = new PropertyFilterDataDefinition(); + propertyFilterDataDefinition.setName("Name1"); + final var propertyFilterConstraint1 = new PropertyFilterConstraintDataDefinition(); + propertyFilterConstraint1.setPropertyName("mem_size"); + propertyFilterConstraint1.setOperator(ConstraintType.EQUAL); + propertyFilterConstraint1.setValue(Map.of("get_property", List.of(prop1, "size"))); + propertyFilterConstraint1.setValueType(FilterValueType.GET_PROPERTY); + propertyFilterConstraint1.setTargetType(PropertyFilterTargetType.PROPERTY); + propertyFilterDataDefinition.setConstraints(List.of(propertyFilterConstraint1)); - ListDataDefinition listDataDefinition = + final var propertyFilterDataDefinition2 = new PropertyFilterDataDefinition(); + propertyFilterDataDefinition2.setName("Name2"); + final var propertyFilterConstraint2 = new PropertyFilterConstraintDataDefinition(); + propertyFilterConstraint2.setPropertyName("mem_size"); + propertyFilterConstraint2.setOperator(ConstraintType.EQUAL); + propertyFilterConstraint2.setValue(Map.of("get_property", List.of("SELF", prop2))); + propertyFilterConstraint2.setValueType(FilterValueType.GET_PROPERTY); + propertyFilterConstraint2.setTargetType(PropertyFilterTargetType.PROPERTY); + propertyFilterDataDefinition2.setConstraints(List.of(propertyFilterConstraint2)); + + ListDataDefinition listDataDefinition = new ListDataDefinition<>(Arrays.asList( - requirementNodeFilterPropertyDataDefinition, - requirementNodeFilterPropertyDataDefinition2)); + propertyFilterDataDefinition, + propertyFilterDataDefinition2)); nodeFilterDataDefinition.setProperties(listDataDefinition); String componentId = "componentId"; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraintTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraintTest.java index 6fd578856d..621c95109e 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraintTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraintTest.java @@ -24,6 +24,7 @@ package org.openecomp.sdc.be.model.tosca.constraints; import static org.junit.Assert.assertEquals; import org.junit.Test; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; import org.openecomp.sdc.be.model.PropertyConstraint; import org.openecomp.sdc.be.model.tosca.ToscaType; import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractStringPropertyConstraintTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractStringPropertyConstraintTest.java index 376bac8ca9..595437fab6 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractStringPropertyConstraintTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractStringPropertyConstraintTest.java @@ -24,6 +24,7 @@ package org.openecomp.sdc.be.model.tosca.constraints; import static org.junit.Assert.assertEquals; import org.junit.Test; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; import org.openecomp.sdc.be.model.PropertyConstraint; import org.openecomp.sdc.be.model.tosca.ToscaType; import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/FilterConstraintMapperTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/FilterConstraintMapperTest.java new file mode 100644 index 0000000000..1ea72937b9 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/FilterConstraintMapperTest.java @@ -0,0 +1,142 @@ +/* + * - + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Nordix Foundation. + * ================================================================================ + * Licensed 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. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.ui.mapper; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Map; +import java.util.Optional; +import org.junit.jupiter.api.Test; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ToscaConcatFunction; +import org.openecomp.sdc.be.datatypes.elements.ToscaFunction; +import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionType; +import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; +import org.openecomp.sdc.be.datatypes.enums.FilterValueType; +import org.openecomp.sdc.be.datatypes.enums.PropertyFilterTargetType; +import org.openecomp.sdc.be.model.dto.FilterConstraintDto; +import org.openecomp.sdc.be.ui.model.UIConstraint; + +class FilterConstraintMapperTest { + + private final FilterConstraintMapper filterConstraintMapper = new FilterConstraintMapper(); + + @Test + void mapFromUIConstraintTest() { + //given + final var uIConstraint = new UIConstraint(); + final FilterValueType filterValueType = FilterValueType.STATIC; + uIConstraint.setSourceType(filterValueType.getName()); + final String capabilityName = "aCapability"; + uIConstraint.setCapabilityName(capabilityName); + final String propertyName = "aProperty"; + uIConstraint.setServicePropertyName(propertyName); + final ConstraintType operator = ConstraintType.GREATER_OR_EQUAL; + uIConstraint.setConstraintOperator(operator.getType()); + final ToscaFunctionType expectedValueToscaFunctionType = ToscaFunctionType.GET_INPUT; + uIConstraint.setValue(Map.of("type", expectedValueToscaFunctionType.getName())); + //when + final FilterConstraintDto filterConstraintDto = filterConstraintMapper.mapFrom(uIConstraint); + //then + assertEquals(PropertyFilterTargetType.CAPABILITY, filterConstraintDto.getTargetType()); + assertEquals(propertyName, filterConstraintDto.getPropertyName()); + assertEquals(capabilityName, filterConstraintDto.getCapabilityName()); + assertEquals(filterValueType, filterConstraintDto.getValueType()); + assertTrue(filterConstraintDto.getValue() instanceof ToscaGetFunctionDataDefinition); + assertEquals(expectedValueToscaFunctionType, ((ToscaGetFunctionDataDefinition) filterConstraintDto.getValue()).getType()); + assertEquals(operator, filterConstraintDto.getOperator()); + //when + final UIConstraint actualUiConstraint = filterConstraintMapper.mapToUiConstraint(filterConstraintDto); + //then + assertEquals(propertyName, actualUiConstraint.getServicePropertyName()); + assertEquals(capabilityName, actualUiConstraint.getCapabilityName()); + assertEquals(filterValueType.getName(), actualUiConstraint.getSourceType()); + assertTrue(actualUiConstraint.getValue() instanceof ToscaGetFunctionDataDefinition); + assertEquals(expectedValueToscaFunctionType, ((ToscaGetFunctionDataDefinition) actualUiConstraint.getValue()).getType()); + assertEquals(operator.getType(), actualUiConstraint.getConstraintOperator()); + assertNull(actualUiConstraint.getSourceName()); + } + + @Test + void mapFromPropertyFilterConstraintDataDefinitionTest() { + //given + final var propertyFilterConstraintDataDefinition = new PropertyFilterConstraintDataDefinition(); + propertyFilterConstraintDataDefinition.setTargetType(PropertyFilterTargetType.CAPABILITY); + final String capabilityName = "aCapability"; + propertyFilterConstraintDataDefinition.setCapabilityName(capabilityName); + final String propertyName = "aProperty"; + propertyFilterConstraintDataDefinition.setPropertyName(propertyName); + final ConstraintType operator = ConstraintType.GREATER_OR_EQUAL; + propertyFilterConstraintDataDefinition.setOperator(operator); + final FilterValueType filterValueType = FilterValueType.STATIC; + propertyFilterConstraintDataDefinition.setValueType(filterValueType); + final String value = "aStaticValue"; + propertyFilterConstraintDataDefinition.setValue(value); + //when + final FilterConstraintDto filterConstraintDto = filterConstraintMapper.mapFrom(propertyFilterConstraintDataDefinition); + //then + assertEquals(PropertyFilterTargetType.CAPABILITY, filterConstraintDto.getTargetType()); + assertEquals(propertyName, filterConstraintDto.getPropertyName()); + assertEquals(capabilityName, filterConstraintDto.getCapabilityName()); + assertEquals(filterValueType, filterConstraintDto.getValueType()); + assertEquals(value, filterConstraintDto.getValue()); + assertEquals(operator, filterConstraintDto.getOperator()); + //when + final PropertyFilterConstraintDataDefinition actualPropertyFilterConstraint = + filterConstraintMapper.mapTo(filterConstraintDto); + assertEquals(PropertyFilterTargetType.CAPABILITY, actualPropertyFilterConstraint.getTargetType()); + assertEquals(propertyName, actualPropertyFilterConstraint.getPropertyName()); + assertEquals(capabilityName, actualPropertyFilterConstraint.getCapabilityName()); + assertEquals(filterValueType, actualPropertyFilterConstraint.getValueType()); + assertEquals(value, actualPropertyFilterConstraint.getValue()); + assertEquals(operator, actualPropertyFilterConstraint.getOperator()); + } + + @Test + void parseValueToToscaFunctionTest() { + //given + final ToscaConcatFunction expectedValue = new ToscaConcatFunction(); + //when + Optional actualToscaFunction = filterConstraintMapper.parseValueToToscaFunction(expectedValue); + //then + assertTrue(actualToscaFunction.isPresent()); + assertEquals(expectedValue, actualToscaFunction.get()); + //when + actualToscaFunction = filterConstraintMapper.parseValueToToscaFunction("not a tosca function"); + //then + assertTrue(actualToscaFunction.isEmpty()); + //given + final Map value = Map.of("type", ToscaFunctionType.CONCAT.getName()); + //when + actualToscaFunction = filterConstraintMapper.parseValueToToscaFunction(value); + //then + assertTrue(actualToscaFunction.isPresent()); + assertTrue(actualToscaFunction.get() instanceof ToscaConcatFunction); + //when + actualToscaFunction = filterConstraintMapper.parseValueToToscaFunction(Map.of("type", 1)); + //then + assertTrue(actualToscaFunction.isEmpty()); + } +} \ No newline at end of file -- cgit 1.2.3-korg