summaryrefslogtreecommitdiffstats
path: root/catalog-be
diff options
context:
space:
mode:
authorJvD_Ericsson <jeff.van.dam@est.tech>2023-05-30 14:57:47 +0100
committerJEFF VAN DAM <jeff.van.dam@est.tech>2023-06-01 14:10:01 +0000
commitbfd727385b9c55d079a5c213b425e88b88a67b7f (patch)
tree846a85428bbeff2297aafe8c6c4d33d771a16c2a /catalog-be
parent57dfe38027308533391d437956e57ac5de0eddc3 (diff)
Fix formatting error for operation input of complex type
Issue-ID: SDC-4523 Signed-off-by: JvD_Ericsson <jeff.van.dam@est.tech> Change-Id: I3dff94cee1d1dbcb26099d02505a679249a6b46e
Diffstat (limited to 'catalog-be')
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/YamlTemplateParsingHandler.java11
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java129
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java258
3 files changed, 179 insertions, 219 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/YamlTemplateParsingHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/YamlTemplateParsingHandler.java
index bdb659b259..b90e3bb0b8 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/YamlTemplateParsingHandler.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/YamlTemplateParsingHandler.java
@@ -1288,12 +1288,23 @@ public class YamlTemplateParsingHandler {
final OperationInputDefinition operationInput
) {
if (value instanceof Map) {
+ final Map<String, Object> valueMap = (Map<String, Object>) value;
log.debug("Creating interface operation input '{}'", inputName);
Type type = new TypeToken<LinkedHashMap<String, Object>>() {
}.getType();
String stringValue = gson.toJson(value, type);
if (toscaFunctionYamlParsingHandler.isPropertyValueToscaFunction(value)) {
toscaFunctionYamlParsingHandler.buildToscaFunctionBasedOnPropertyValue((Map<String, Object>) value).ifPresent(operationInput::setToscaFunction);
+ } else {
+ final Collection<SubPropertyToscaFunction> subPropertyToscaFunctions = buildSubPropertyToscaFunctions(valueMap, new ArrayList<>());
+ if (CollectionUtils.isNotEmpty(subPropertyToscaFunctions)) {
+ Collection<SubPropertyToscaFunction> existingSubPropertyToscaFunctions = operationInput.getSubPropertyToscaFunctions();
+ if (existingSubPropertyToscaFunctions == null) {
+ operationInput.setSubPropertyToscaFunctions(subPropertyToscaFunctions);
+ } else {
+ operationInput.getSubPropertyToscaFunctions().addAll(subPropertyToscaFunctions);
+ }
+ }
}
operationInput.setValue(stringValue);
}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
index 8f5f271407..e56472a426 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
package org.openecomp.sdc.be.tosca;
import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
@@ -20,28 +21,35 @@ import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.google.gson.Gson;
+import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
+import org.json.JSONObject;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ToscaFunction;
+import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionType;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.DataTypeDefinition;
@@ -82,42 +90,6 @@ public class InterfacesOperationsConverter {
this.propertyConvertor = propertyConvertor;
}
- /**
- * Creates the interface_types element.
- *
- * @param component to work on
- * @return the added element
- */
- public Map<String, Object> addInterfaceTypeElement(Component component, List<String> allInterfaceTypes) {
- if (component instanceof Product) {
- return null;
- }
- final Map<String, InterfaceDefinition> interfaces = component.getInterfaces();
- if (MapUtils.isEmpty(interfaces)) {
- return null;
- }
- Map<String, Object> toscaInterfaceTypes = new HashMap<>();
- for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
- boolean isInterfaceTypeExistInGlobalType = allInterfaceTypes.stream()
- .anyMatch(type -> type.equalsIgnoreCase(interfaceDefinition.getType()));
- if (!isInterfaceTypeExistInGlobalType) {
- ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
- toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
- final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
- Map<String, Object> toscaOperations = new HashMap<>();
- for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
- toscaOperations.put(operationEntry.getValue().getName(), null);
- }
- toscaInterfaceType.setOperations(toscaOperations);
- Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
- Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS.getElementName());
- interfacesAsMap.putAll(operationsMap);
- toscaInterfaceTypes.put(getInterfaceType(component, LOCAL_INTERFACE_TYPE), interfacesAsMap);
- }
- }
- return MapUtils.isNotEmpty(toscaInterfaceTypes) ? toscaInterfaceTypes : null;
- }
-
private static Object getDefaultValue(Map<String, Object> inputValueMap) {
Object defaultValue = null;
for (Map.Entry<String, Object> operationEntry : inputValueMap.entrySet()) {
@@ -153,11 +125,6 @@ public class InterfacesOperationsConverter {
return toscaResourceName.substring(toscaResourceName.lastIndexOf(DOT) + 1);
}
- private boolean isArtifactPresent(final OperationDataDefinition operationDataDefinition) {
- return operationDataDefinition.getImplementation() != null
- && StringUtils.isNotEmpty(operationDataDefinition.getImplementation().getArtifactName());
- }
-
private static String getInputValue(final OperationInputDefinition input) {
if (null != input.getToscaFunction()) {
return input.getToscaFunction().getJsonObjectValue().toString();
@@ -173,10 +140,42 @@ public class InterfacesOperationsConverter {
mappedOutputValue.remove(1);
mappedOutputValue.add(1, interfaceName);
inputValue = gson.toJson(consumptionValue);
+ } else {
+ String finalInputValue = inputValue;
+ if (inputValue != null &&
+ Arrays.stream(ToscaFunctionType.values()).anyMatch(toscaType -> finalInputValue.contains(toscaType.getName().toUpperCase()))) {
+ inputValue = getInputValuesAsToscaFunction(inputValue);
+ }
}
return inputValue;
}
+ private static String getInputValuesAsToscaFunction(String inputValue) {
+ Gson gson = new Gson();
+ Map<String, Object> mapOfValues = gson.fromJson(inputValue, Map.class);
+ for (Entry<String, Object> entry : mapOfValues.entrySet()) {
+ Object value = entry.getValue();
+ if (value instanceof Map) {
+ Map<String, Object> valueMap = (Map<String, Object>) value;
+ if (valueMap.containsKey("type")) {
+ String type = (String) valueMap.get("type");
+ Optional<ToscaFunctionType> toscaType = ToscaFunctionType.findType(type);
+ if (toscaType.isPresent()) {
+ ObjectMapper mapper = new ObjectMapper();
+ try {
+ String json = gson.toJson(value);
+ ToscaFunction toscaFunction = mapper.readValue(json, ToscaFunction.class);
+ entry.setValue(toscaFunction.getJsonObjectValue());
+ } catch (JsonProcessingException e) {
+ throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
+ }
+ }
+ }
+ }
+ }
+ return String.valueOf(new JSONObject(mapOfValues));
+ }
+
private static String getInterfaceType(Component component, String interfaceType) {
if (LOCAL_INTERFACE_TYPE.equals(interfaceType)) {
return DERIVED_FROM_BASE_DEFAULT + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName();
@@ -208,6 +207,47 @@ public class InterfacesOperationsConverter {
}
/**
+ * Creates the interface_types element.
+ *
+ * @param component to work on
+ * @return the added element
+ */
+ public Map<String, Object> addInterfaceTypeElement(Component component, List<String> allInterfaceTypes) {
+ if (component instanceof Product) {
+ return null;
+ }
+ final Map<String, InterfaceDefinition> interfaces = component.getInterfaces();
+ if (MapUtils.isEmpty(interfaces)) {
+ return null;
+ }
+ Map<String, Object> toscaInterfaceTypes = new HashMap<>();
+ for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
+ boolean isInterfaceTypeExistInGlobalType = allInterfaceTypes.stream()
+ .anyMatch(type -> type.equalsIgnoreCase(interfaceDefinition.getType()));
+ if (!isInterfaceTypeExistInGlobalType) {
+ ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
+ toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
+ final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
+ Map<String, Object> toscaOperations = new HashMap<>();
+ for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
+ toscaOperations.put(operationEntry.getValue().getName(), null);
+ }
+ toscaInterfaceType.setOperations(toscaOperations);
+ Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
+ Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS.getElementName());
+ interfacesAsMap.putAll(operationsMap);
+ toscaInterfaceTypes.put(getInterfaceType(component, LOCAL_INTERFACE_TYPE), interfacesAsMap);
+ }
+ }
+ return MapUtils.isNotEmpty(toscaInterfaceTypes) ? toscaInterfaceTypes : null;
+ }
+
+ private boolean isArtifactPresent(final OperationDataDefinition operationDataDefinition) {
+ return operationDataDefinition.getImplementation() != null
+ && StringUtils.isNotEmpty(operationDataDefinition.getImplementation().getArtifactName());
+ }
+
+ /**
* Adds the 'interfaces' element to the node type provided.
*
* @param component to work on
@@ -302,9 +342,10 @@ public class InterfacesOperationsConverter {
interfaceDefinitionAsMap.putAll(operationsMap);
toscaInterfaceDefinitions.put(getLastPartOfName(interfaceType), interfaceDefinitionAsMap);
}
-
+
private boolean operationHasAnImplementation(OperationDataDefinition operation) {
- return operation.getImplementation() != null && StringUtils.isNotEmpty(operation.getImplementation().getArtifactName()) && !operation.getImplementation().getArtifactName().equals("''");
+ return operation.getImplementation() != null && StringUtils.isNotEmpty(operation.getImplementation().getArtifactName()) &&
+ !operation.getImplementation().getArtifactName().equals("''");
}
private void handleInterfaceOperationImplementation(final Component component, final ComponentInstance componentInstance,
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java
index b3470561f2..5158ae7945 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java
@@ -19,41 +19,27 @@
package org.openecomp.sdc.be.tosca;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INTERFACES;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE_TYPES;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
-import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Objects;
-import java.util.function.Function;
-import java.util.stream.Collectors;
import org.apache.commons.collections4.MapUtils;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import org.onap.sdc.tosca.services.YamlUtil;
import org.openecomp.sdc.be.DummyConfigurationManager;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
@@ -68,15 +54,14 @@ import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.model.ServiceMetadataDefinition;
import org.openecomp.sdc.be.model.tosca.ToscaType;
import org.openecomp.sdc.be.tosca.model.ToscaInterfaceDefinition;
import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
-import org.openecomp.sdc.common.util.YamlToObjectConverter;
import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
-import org.yaml.snakeyaml.Yaml;
class InterfacesOperationsConverterTest {
@@ -84,10 +69,9 @@ class InterfacesOperationsConverterTest {
private static final String INPUT_NAME_PREFIX = "input_";
private static final String OUTPUT_NAME_PREFIX = "output_";
private static final String NODE_TYPE_NAME = "test";
- private final String[] inputTypes = {"string", "integer", "float", "boolean"};
- private static ObjectMapper mapper;
private static final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
-
+ private static ObjectMapper mapper;
+ private final String[] inputTypes = {"string", "integer", "float", "boolean"};
private InterfacesOperationsConverter interfacesOperationsConverter;
@BeforeAll
@@ -112,7 +96,7 @@ class InterfacesOperationsConverterTest {
component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("Local");
- addOperationsToInterface(component, addedInterface, 5, 3, true, false);
+ addOperationsToInterface(component, addedInterface, 5, 3, true, false, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
@@ -135,7 +119,7 @@ class InterfacesOperationsConverterTest {
component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("Local");
- addOperationsToInterface(component, addedInterface, 5, 3, true, false);
+ addOperationsToInterface(component, addedInterface, 5, 3, true, false, false);
final String interfaceType = "normalizedServiceComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
@@ -156,7 +140,7 @@ class InterfacesOperationsConverterTest {
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("com.some.resource.or.other.resourceName");
- addOperationsToInterface(component, addedInterface, 3, 2, true, false);
+ addOperationsToInterface(component, addedInterface, 3, 2, true, false, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
@@ -179,7 +163,7 @@ class InterfacesOperationsConverterTest {
component.setNormalizedName("normalizedServiceComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("com.some.service.or.other.serviceName");
- addOperationsToInterface(component, addedInterface, 3, 2, true, false);
+ addOperationsToInterface(component, addedInterface, 3, 2, true, false, false);
final String interfaceType = "normalizedServiceComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
@@ -196,7 +180,6 @@ class InterfacesOperationsConverterTest {
}
-
@Test
void testGetInterfaceAsMapServiceProxy() {
Component component = new Resource();
@@ -204,7 +187,7 @@ class InterfacesOperationsConverterTest {
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
addedInterface.setType("com.some.resource.or.other.resourceName");
- addOperationsToInterface(component, addedInterface, 3, 2, true, false);
+ addOperationsToInterface(component, addedInterface, 3, 2, true, false, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
@@ -225,7 +208,7 @@ class InterfacesOperationsConverterTest {
component.setNormalizedName("normalizedComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs");
- addOperationsToInterface(component, addedInterface, 3, 3, false, false);
+ addOperationsToInterface(component, addedInterface, 3, 3, false, false, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
@@ -249,7 +232,7 @@ class InterfacesOperationsConverterTest {
component.setNormalizedName("normalizedComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType(addedInterfaceType);
- addOperationsToInterface(component, addedInterface, 2, 2, true, true);
+ addOperationsToInterface(component, addedInterface, 2, 2, true, true, false);
addedInterface.getOperationsMap().values().stream()
.filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
"name_for_op_0"))
@@ -280,7 +263,7 @@ class InterfacesOperationsConverterTest {
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType(addedInterfaceType);
addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
- addOperationsToInterface(component, addedInterface, 2, 2, true, true);
+ addOperationsToInterface(component, addedInterface, 2, 2, true, true, false);
addedInterface.getOperationsMap().values().stream()
.filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
"name_for_op_0"))
@@ -293,7 +276,7 @@ class InterfacesOperationsConverterTest {
InterfaceDefinition secondInterface = new InterfaceDefinition();
secondInterface.setType(secondInterfaceType);
secondInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
- addOperationsToInterface(component, secondInterface, 2, 2, true, true);
+ addOperationsToInterface(component, secondInterface, 2, 2, true, true, false);
secondInterface.getOperationsMap().values().stream()
.filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
"name_for_op_0"))
@@ -408,65 +391,8 @@ class InterfacesOperationsConverterTest {
assertTrue(expectedListOfStringPropValue.contains("value3"));
}
-
- private void validateInterfaceInputs(final String yaml, final String interfaceName, final Map<String, InputDataDefinition> expectedInputMap) {
- String fixedMainYaml = yaml;
- final String nullString = "null";
- if (fixedMainYaml.startsWith(nullString)) {
- fixedMainYaml = yaml.substring(nullString.length());
- }
- if (fixedMainYaml.endsWith(nullString)) {
- fixedMainYaml = fixedMainYaml.substring(0, fixedMainYaml.length() - nullString.length());
- }
- final Map<String, Object> yamlMap = new Yaml().load(fixedMainYaml);
- final Map<String, Object> nodeTypesMap = (Map<String, Object>) yamlMap.get(NODE_TYPES.getElementName());
- final Map<String, Object> node = (Map<String, Object>) nodeTypesMap.get(NODE_TYPE_NAME);
- final Map<String, Object> interfacesMap = (Map<String, Object>) node.get(INTERFACES.getElementName());
- final Map<String, Object> interface1 = (Map<String, Object>) interfacesMap.get(interfaceName);
- final Map<String, Object> actualInputsMap = (Map<String, Object>) interface1.get(INPUTS.getElementName());
- assertThat(actualInputsMap.keySet(), containsInAnyOrder(expectedInputMap.keySet().toArray()));
- expectedInputMap.forEach((inputName, inputDataDefinition) -> {
- final Map<String, Object> actualInput = (Map<String, Object>) actualInputsMap.get(inputName);
- compareInputYaml(inputName, actualInput, inputDataDefinition);
- });
- }
-
- private void compareInputYaml(final String inputName, final Map<String, Object> actualInput,
- final InputDataDefinition expectedInput) {
- final String msgFormat = "%s should be equal in input %s";
- String field = TYPE.getElementName();
- assertThat(String.format(msgFormat, field, inputName),
- actualInput.get(field), equalTo(expectedInput.getType()));
- field = DESCRIPTION.getElementName();
- assertThat(String.format(msgFormat, field, inputName),
- actualInput.get(field), equalTo(expectedInput.getDescription()));
- field = REQUIRED.getElementName();
- assertThat(String.format(msgFormat, field, inputName),
- actualInput.get(field), equalTo(expectedInput.getRequired()));
- field = DEFAULT.getElementName();
- assertThat(String.format(msgFormat, field, inputName),
- actualInput.get(field), equalTo(expectedInput.getDefaultValue()));
- }
-
- @FunctionalInterface
- interface MainYamlAssertion extends Function<String, Boolean> {
-
- }
-
- private static Function<String, Boolean> all(MainYamlAssertion... fs) {
- return s -> io.vavr.collection.List.of(fs).map(f -> f.apply(s)).fold(true, (l, r) -> l && r);
- }
-
- private static MainYamlAssertion containsNone(String... expected) {
- return s -> io.vavr.collection.List.of(expected).map(e -> !s.contains(e)).fold(true, (l, r) -> l && r);
- }
-
- private static MainYamlAssertion containsAll(String... expected) {
- return s -> io.vavr.collection.List.of(expected).map(s::contains).fold(true, (l, r) -> l && r);
- }
-
private void addOperationsToInterface(Component component, InterfaceDefinition addedInterface, int numOfOps,
- int numOfInputsPerOp, boolean hasInputs, boolean hasOutputs) {
+ int numOfInputsPerOp, boolean hasInputs, boolean hasOutputs, boolean addAComplexType) {
addedInterface.setOperations(new HashMap<>());
for (int i = 0; i < numOfOps; i++) {
@@ -477,7 +403,7 @@ class InterfacesOperationsConverterTest {
implementation.setArtifactName(i + "_createBPMN.bpmn");
operation.setImplementation(implementation);
if (hasInputs) {
- operation.setInputs(createInputs(component, numOfInputsPerOp));
+ operation.setInputs(createInputs(component, numOfInputsPerOp, addAComplexType));
}
if (hasOutputs) {
operation.setOutputs(createOutputs(addedInterface.getToscaResourceName(),
@@ -505,8 +431,14 @@ class InterfacesOperationsConverterTest {
return new InputDataDefinition(propertyDataDefinition);
}
- private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs) {
+ private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs, boolean addAComplexType) {
ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
+ if (addAComplexType) {
+ String mappedPropertyName = java.util.UUID.randomUUID() + "." + MAPPED_PROPERTY_NAME + numOfInputs;
+ operationInputDefinitionList.add(
+ createMockComplexOperationInputDefinition(INPUT_NAME_PREFIX + "Complex" + "_" + numOfInputs, mappedPropertyName));
+ numOfInputs -= 1;
+ }
for (int i = 0; i < numOfInputs; i++) {
String mappedPropertyName = java.util.UUID.randomUUID() + "." + MAPPED_PROPERTY_NAME + i;
operationInputDefinitionList.add(createMockOperationInputDefinition(
@@ -554,6 +486,17 @@ class InterfacesOperationsConverterTest {
return operationInputDefinition;
}
+ private OperationInputDefinition createMockComplexOperationInputDefinition(String name, String id) {
+ OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
+ operationInputDefinition.setName(name);
+ operationInputDefinition.setInputId(id);
+ operationInputDefinition.setType("complexDataType");
+ operationInputDefinition.setRequired(false);
+ operationInputDefinition.setValue(
+ "{\"intProp\":1,\"stringProp\":{\"type\":\"GET_ATTRIBUTE\",\"propertyUniqueId\":\"ac4bc339-56d1-4ea2-9802-2da219a1247a.designer\",\"propertyName\":\"designer\",\"propertySource\":\"SELF\",\"sourceUniqueId\":\"ac4bc339-56d1-4ea2-9802-2da219a1247a\",\"sourceName\":\"service\",\"functionType\":\"GET_ATTRIBUTE\",\"propertyPathFromSource\":[\"designer\"]}}");
+ return operationInputDefinition;
+ }
+
private OperationOutputDefinition createMockOperationOutputDefinition(String interfaceName, String operationName,
String outputName, int index) {
OperationOutputDefinition operationInputDefinition = new OperationOutputDefinition();
@@ -570,91 +513,6 @@ class InterfacesOperationsConverterTest {
return operationInputDefinition;
}
- private void validateOperationInputs(final String mainYaml, int numOfInputsPerOp, String mappedOperationName) {
- String nodeTypeKey = NODE_TYPE_NAME + ":";
- String nodeTypesRepresentation = mainYaml.substring(mainYaml.indexOf(nodeTypeKey) + nodeTypeKey.length(),
- mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length()
- + String.valueOf(numOfInputsPerOp).length());
- YamlToObjectConverter objectConverter = new YamlToObjectConverter();
- ToscaNodeType toscaNodeType = objectConverter.convert(nodeTypesRepresentation.getBytes(), ToscaNodeType.class);
- Map<String, Object> interfaces = toscaNodeType.getInterfaces();
- for (Map.Entry<String, Object> interfaceEntry : interfaces.entrySet()) {
- Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class);
- final Map<String, Object> operationsMap = interfaceDefinition.entrySet().stream()
- .filter(entry -> !INPUTS.getElementName().equals(entry.getKey()) &&
- !TYPE.getElementName().equals(entry.getKey()))
- .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
- for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
- Object operationVal = operationEntry.getValue();
- if (operationVal instanceof Map) {
- //Since the inputs are mapped to output operations from only first interface so using that name
- validateOperationInputDefinition(interfaces.keySet().iterator().next(), mappedOperationName,
- operationVal);
- }
- }
- }
- }
-
- private void validateOperationInputDefinition(String interfaceType, String operationName, Object operationVal) {
- Map<String, Object> operation = mapper.convertValue(operationVal, Map.class);
- Map<String, Object> inputs = (Map<String, Object>) operation.get("inputs");
- for (Map.Entry<String, Object> inputEntry : inputs.entrySet()) {
- String[] inputNameSplit = inputEntry.getKey().split("_");
- Map<String, Object> inputValueObject = (Map<String, Object>) inputEntry.getValue();
- validateOperationInputDefinitionDefaultValue(interfaceType, operationName, inputNameSplit[1],
- Integer.parseInt(inputNameSplit[2]), inputValueObject);
- }
- }
-
-
- private void validateOperationInputDefinitionDefaultValue(String interfaceType, String operationName,
- String inputType, int index,
- Map<String, Object> inputValueObject) {
- if (inputValueObject.containsKey(ToscaFunctions.GET_PROPERTY.getFunctionName())) {
- String mappedPropertyValue = MAPPED_PROPERTY_NAME + index;
- List<String> mappedPropertyDefaultValue = (List<String>) inputValueObject
- .get(ToscaFunctions.GET_PROPERTY.getFunctionName());
- assertEquals(2, mappedPropertyDefaultValue.size());
- assertTrue(mappedPropertyDefaultValue.contains(SELF));
- assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
- } else if (inputValueObject.containsKey(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) {
- List<String> mappedPropertyDefaultValue = (List<String>) inputValueObject
- .get(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName());
- assertEquals(4, mappedPropertyDefaultValue.size());
- String mappedPropertyValue = OUTPUT_NAME_PREFIX + inputType + "_" + index;
- assertTrue(mappedPropertyDefaultValue.contains(SELF));
- assertTrue(mappedPropertyDefaultValue.contains(interfaceType));
- assertTrue(mappedPropertyDefaultValue.contains(operationName));
- assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
- } else {
- fail("Invalid Tosca function in default value. Allowed values: " + ToscaFunctions.GET_PROPERTY.getFunctionName() +
- "/" + ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName());
- }
- }
-
- private void validateServiceProxyOperationInputs(String mainYaml) {
- String nodeTypeKey = NODE_TYPE_NAME + ":";
- String nodeTypesRepresentation = mainYaml.substring(mainYaml.indexOf(nodeTypeKey) + nodeTypeKey.length(),
- mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length());
- YamlUtil yamlUtil = new YamlUtil();
- ToscaNodeType toscaNodeType = yamlUtil.yamlToObject(nodeTypesRepresentation, ToscaNodeType.class);
- for (Object interfaceVal : toscaNodeType.getInterfaces().values()) {
- Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceVal, Map.class);
- for (Object operationVal : interfaceDefinition.values()) {
- if (operationVal instanceof Map) {
- Map<String, Object> operation = (Map<String, Object>) mapper.convertValue(operationVal, Map.class);
- Map<String, Object> operationInputs = (Map<String, Object>) operation.get("inputs");
- for (Object inputValue : operationInputs.values()) {
- Map<String, Object> inputValueAsMap = (Map<String, Object>) inputValue;
- assertFalse(inputValueAsMap.keySet().contains("type"));
- assertFalse(inputValueAsMap.keySet().contains("required"));
- assertFalse(inputValueAsMap.keySet().contains("default"));
- }
- }
- }
- }
- }
-
@Test
void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() {
Service service = new Service();
@@ -685,6 +543,56 @@ class InterfacesOperationsConverterTest {
}
@Test
+ void testGetInterfaceAsMapWithComplexType() {
+ addComplexTypeToDataTypes();
+ Component component = new Resource();
+ component.setNormalizedName("normalizedComponentName");
+ InterfaceDefinition addedInterface = new InterfaceDefinition();
+ addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
+ addedInterface.setType("com.some.resource.or.other.resourceName");
+ addOperationsToInterface(component, addedInterface, 3, 2, true, false, true);
+ final String interfaceType = "normalizedComponentName-interface";
+ component.setInterfaces(new HashMap<>());
+ component.getInterfaces().put(interfaceType, addedInterface);
+ final var interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), dataTypes, false);
+ assertNotNull(interfacesMap);
+ assertEquals(1, interfacesMap.size());
+ assertTrue(interfacesMap.containsKey("resourceName"));
+ Object resourceName = interfacesMap.get("resourceName");
+ assertNotNull(resourceName);
+ assertTrue(resourceName instanceof Map);
+ assertEquals(4, ((Map) resourceName).size());
+ assertTrue(resourceName instanceof Map);
+ Map<String, Object> resource = (Map<String, Object>) resourceName;
+ assertTrue(resource.containsKey("name_for_op_0"));
+ Map<String, Object> operation0 = (Map<String, Object>) resource.get("name_for_op_0");
+ assertTrue(operation0.containsKey("inputs"));
+ Map<String, Object> operation0Inputs = (Map<String, Object>) operation0.get("inputs");
+ assertTrue(operation0Inputs.containsKey("input_Complex_2"));
+ Map<String, Object> complexInput = (Map<String, Object>) operation0Inputs.get("input_Complex_2");
+ assertTrue(complexInput.containsKey("stringProp"));
+ Map<String, Object> complexInputStringProp = (Map<String, Object>) complexInput.get("stringProp");
+ assertTrue(complexInputStringProp.containsKey("get_attribute"));
+ List<String> complexInputStringPropToscaFunction = (List<String>) complexInputStringProp.get("get_attribute");
+ assertEquals(2, complexInputStringPropToscaFunction.size());
+ assertEquals("SELF", complexInputStringPropToscaFunction.get(0));
+ assertEquals("designer", complexInputStringPropToscaFunction.get(1));
+ }
+
+ private void addComplexTypeToDataTypes() {
+ PropertyDefinition intProp = new PropertyDefinition();
+ intProp.setType("integer");
+ intProp.setName("intProp");
+ PropertyDefinition stringProp = new PropertyDefinition();
+ stringProp.setType("string");
+ stringProp.setName("stringProp");
+ DataTypeDefinition dataType = new DataTypeDefinition();
+ dataType.setName("complexDataType");
+ dataType.setProperties(new ArrayList<>(Arrays.asList(stringProp, intProp)));
+ dataTypes.put("complexDataType", dataType);
+ }
+
+ @Test
void testRemoveInterfacesWithoutOperationsEmptyMap() {
final Map<String, Object> interfaceMap = new HashMap<>();
interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);