2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2020 Nordix Foundation
4 * ================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 * SPDX-License-Identifier: Apache-2.0
17 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.tosca;
22 import static org.junit.jupiter.api.Assertions.assertEquals;
23 import static org.junit.jupiter.api.Assertions.assertFalse;
24 import static org.junit.jupiter.api.Assertions.assertNotNull;
25 import static org.junit.jupiter.api.Assertions.assertNull;
26 import static org.junit.jupiter.api.Assertions.assertTrue;
27 import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.createMappedOutputDefaultValue;
28 import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
30 import com.fasterxml.jackson.databind.DeserializationFeature;
31 import com.fasterxml.jackson.databind.ObjectMapper;
32 import com.google.gson.Gson;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.Collections;
36 import java.util.HashMap;
37 import java.util.List;
39 import java.util.Objects;
40 import org.apache.commons.collections4.MapUtils;
41 import org.junit.jupiter.api.BeforeAll;
42 import org.junit.jupiter.api.BeforeEach;
43 import org.junit.jupiter.api.Test;
44 import org.openecomp.sdc.be.DummyConfigurationManager;
45 import org.openecomp.sdc.be.datatypes.elements.ActivityDataDefinition;
46 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
47 import org.openecomp.sdc.be.datatypes.elements.FilterDataDefinition;
48 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
49 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
50 import org.openecomp.sdc.be.datatypes.elements.MilestoneDataDefinition;
51 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
52 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
53 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
54 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
55 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
56 import org.openecomp.sdc.be.datatypes.elements.ToscaFunctionType;
57 import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
58 import org.openecomp.sdc.be.datatypes.enums.ActivityTypeEnum;
59 import org.openecomp.sdc.be.datatypes.enums.ConstraintType;
60 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
61 import org.openecomp.sdc.be.datatypes.enums.MilestoneTypeEnum;
62 import org.openecomp.sdc.be.datatypes.enums.PropertySource;
63 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
64 import org.openecomp.sdc.be.model.Component;
65 import org.openecomp.sdc.be.model.DataTypeDefinition;
66 import org.openecomp.sdc.be.model.InputDefinition;
67 import org.openecomp.sdc.be.model.InterfaceDefinition;
68 import org.openecomp.sdc.be.model.PropertyDefinition;
69 import org.openecomp.sdc.be.model.Resource;
70 import org.openecomp.sdc.be.model.Service;
71 import org.openecomp.sdc.be.model.ServiceMetadataDefinition;
72 import org.openecomp.sdc.be.model.tosca.ToscaType;
73 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceDefinition;
74 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
75 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
77 class InterfacesOperationsConverterTest {
79 private static final String MAPPED_PROPERTY_NAME = "mapped_property";
80 private static final String INPUT_NAME_PREFIX = "input_";
81 private static final String OUTPUT_NAME_PREFIX = "output_";
82 private static final String NODE_TYPE_NAME = "test";
83 private static final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
84 private static ObjectMapper mapper;
85 private final String[] inputTypes = {"string", "integer", "float", "boolean"};
86 private InterfacesOperationsConverter interfacesOperationsConverter;
89 public static void setUp() {
90 //initialize the static configuration manager
91 new DummyConfigurationManager();
92 mapper = new ObjectMapper();
93 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
97 public void setUpBeforeTest() {
98 interfacesOperationsConverter = new InterfacesOperationsConverter(new PropertyConvertor());
102 void addInterfaceTypeElementToResource() {
103 Component component = new Resource();
104 component.setNormalizedName("normalizedComponentName");
105 component.setComponentMetadataDefinition(new ServiceMetadataDefinition());
106 component.getComponentMetadataDefinition().getMetadataDataDefinition().setName("NodeTypeName");
107 component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName");
108 InterfaceDefinition addedInterface = new InterfaceDefinition();
109 addedInterface.setType("Local");
110 addOperationsToInterface(component, addedInterface, 5, 3, true, false, false, false);
111 final String interfaceType = "normalizedComponentName-interface";
112 component.setInterfaces(new HashMap<>());
113 component.getInterfaces().put(interfaceType, addedInterface);
114 final Map<String, Object> interfaceTypeElement = interfacesOperationsConverter.addInterfaceTypeElement(component, new ArrayList<>());
115 assertNotNull(interfaceTypeElement);
116 assertTrue(interfaceTypeElement.containsKey("org.openecomp.interfaces.node.lifecycle.NodeTypeName"));
117 Object o = interfaceTypeElement.get("org.openecomp.interfaces.node.lifecycle.NodeTypeName");
119 assertTrue(o instanceof Map);
120 assertEquals(7, ((Map) o).size());
125 void addInterfaceTypeElementToService() {
126 Component component = new Service();
127 component.setNormalizedName("normalizedServiceComponentName");
128 component.setComponentMetadataDefinition(new ServiceMetadataDefinition());
129 component.getComponentMetadataDefinition().getMetadataDataDefinition().setName("NodeTypeName");
130 component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName");
131 InterfaceDefinition addedInterface = new InterfaceDefinition();
132 addedInterface.setType("Local");
133 addOperationsToInterface(component, addedInterface, 5, 3, true, false, false, false);
134 final String interfaceType = "normalizedServiceComponentName-interface";
135 component.setInterfaces(new HashMap<>());
136 component.getInterfaces().put(interfaceType, addedInterface);
137 final Map<String, Object> interfaceTypeElement = interfacesOperationsConverter.addInterfaceTypeElement(component, new ArrayList<>());
138 assertNotNull(interfaceTypeElement);
139 assertTrue(interfaceTypeElement.containsKey("org.openecomp.interfaces.node.lifecycle.NodeTypeName"));
140 Object o = interfaceTypeElement.get("org.openecomp.interfaces.node.lifecycle.NodeTypeName");
142 assertTrue(o instanceof Map);
143 assertEquals(7, ((Map) o).size());
148 void addInterfaceDefinitionElementToResource() {
149 Component component = new Resource();
150 component.setNormalizedName("normalizedComponentName");
151 InterfaceDefinition addedInterface = new InterfaceDefinition();
152 addedInterface.setType("com.some.resource.or.other.resourceName");
154 addOperationsToInterface(component, addedInterface, 3, 2, true, false, false, false);
155 final String interfaceType = "normalizedComponentName-interface";
156 component.setInterfaces(new HashMap<>());
157 component.getInterfaces().put(interfaceType, addedInterface);
158 ToscaNodeType nodeType = new ToscaNodeType();
159 interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
160 Map<String, Object> interfaces = nodeType.getInterfaces();
161 assertNotNull(interfaces);
162 assertEquals(1, interfaces.size());
163 assertTrue(interfaces.containsKey("resourceName"));
164 Object resourceName = interfaces.get("resourceName");
165 assertNotNull(resourceName);
166 assertTrue(resourceName instanceof Map);
167 assertEquals(4, ((Map) resourceName).size());
172 void addInterfaceDefinitionElementToService() {
173 Component component = new Service();
174 component.setNormalizedName("normalizedServiceComponentName");
175 InterfaceDefinition addedInterface = new InterfaceDefinition();
176 addedInterface.setType("com.some.service.or.other.serviceName");
177 addOperationsToInterface(component, addedInterface, 3, 2, true, false, false, false);
178 final String interfaceType = "normalizedServiceComponentName-interface";
179 component.setInterfaces(new HashMap<>());
180 component.getInterfaces().put(interfaceType, addedInterface);
181 ToscaNodeType nodeType = new ToscaNodeType();
182 interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
183 Map<String, Object> interfaces = nodeType.getInterfaces();
184 assertNotNull(interfaces);
185 assertEquals(1, interfaces.size());
186 assertTrue(interfaces.containsKey("serviceName"));
187 Object resourceName = interfaces.get("serviceName");
188 assertNotNull(resourceName);
189 assertTrue(resourceName instanceof Map);
190 assertEquals(4, ((Map) resourceName).size());
195 void testGetInterfaceAsMapServiceProxy() {
196 Component component = new Resource();
197 component.setNormalizedName("normalizedComponentName");
198 InterfaceDefinition addedInterface = new InterfaceDefinition();
199 addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
200 addedInterface.setType("com.some.resource.or.other.resourceName");
201 addOperationsToInterface(component, addedInterface, 3, 2, true, false, false, false);
202 final String interfaceType = "normalizedComponentName-interface";
203 component.setInterfaces(new HashMap<>());
204 component.getInterfaces().put(interfaceType, addedInterface);
205 final var interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), null, false);
206 assertNotNull(interfacesMap);
207 assertEquals(1, interfacesMap.size());
208 assertTrue(interfacesMap.containsKey("resourceName"));
209 Object resourceName = interfacesMap.get("resourceName");
210 assertNotNull(resourceName);
211 assertTrue(resourceName instanceof Map);
212 assertEquals(4, ((Map) resourceName).size());
217 void addInterfaceDefinitionElement_noInputs() {
218 Component component = new Resource();
219 component.setNormalizedName("normalizedComponentName");
220 InterfaceDefinition addedInterface = new InterfaceDefinition();
221 addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs");
222 addOperationsToInterface(component, addedInterface, 3, 3, false, false, false, false);
223 final String interfaceType = "normalizedComponentName-interface";
224 component.setInterfaces(new HashMap<>());
225 component.getInterfaces().put(interfaceType, addedInterface);
226 ToscaNodeType nodeType = new ToscaNodeType();
227 interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, null, false);
228 Map<String, Object> interfaces = nodeType.getInterfaces();
229 assertNotNull(interfaces);
230 assertEquals(1, interfaces.size());
231 assertTrue(interfaces.containsKey("resourceNameNoInputs"));
232 Object resourceName = interfaces.get("resourceNameNoInputs");
233 assertNotNull(resourceName);
234 assertTrue(resourceName instanceof Map);
235 assertEquals(4, ((Map) resourceName).size());
240 void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() {
241 String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput";
242 Component component = new Resource();
243 component.setNormalizedName("normalizedComponentName");
244 InterfaceDefinition addedInterface = new InterfaceDefinition();
245 addedInterface.setType(addedInterfaceType);
246 addOperationsToInterface(component, addedInterface, 2, 2, true, true, false, false);
247 addedInterface.getOperationsMap().values().stream()
248 .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
250 .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream()
251 .filter(operationInputDefinition -> operationInputDefinition.getName().contains("integer"))
252 .forEach(operationInputDefinition -> {
253 operationInputDefinition.setInputId(addedInterfaceType + ".name_for_op_1.output_integer_1");
254 operationInputDefinition.setToscaDefaultValue(
255 new Gson().toJson(createMappedOutputDefaultValue(SELF, operationInputDefinition.getInputId())));
257 component.setInterfaces(new HashMap<>());
258 component.getInterfaces().put(addedInterfaceType, addedInterface);
259 ToscaNodeType nodeType = new ToscaNodeType();
260 interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
261 Map<String, Object> interfaces = nodeType.getInterfaces();
262 assertNotNull(interfaces);
263 assertEquals(1, interfaces.size());
264 assertTrue(interfaces.containsKey("resourceNameInputMappedToOutput"));
265 Object resourceName = interfaces.get("resourceNameInputMappedToOutput");
266 assertNotNull(resourceName);
267 assertTrue(resourceName instanceof Map);
268 assertEquals(3, ((Map) resourceName).size());
273 void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() {
274 String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput";
275 Component component = new Resource();
276 component.setNormalizedName("normalizedComponentName");
277 InterfaceDefinition addedInterface = new InterfaceDefinition();
278 addedInterface.setType(addedInterfaceType);
279 addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
280 addOperationsToInterface(component, addedInterface, 2, 2, true, true, false, false);
281 addedInterface.getOperationsMap().values().stream()
282 .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
284 .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream()
285 .filter(opInputDef -> opInputDef.getName().contains("integer"))
286 .forEach(opInputDef -> opInputDef.setInputId(
287 addedInterfaceType + ".name_for_op_1.output_integer_1")));
288 //Mapping to operation from another interface
289 String secondInterfaceType = "org.test.lifecycle.standard.interfaceType.second";
290 InterfaceDefinition secondInterface = new InterfaceDefinition();
291 secondInterface.setType(secondInterfaceType);
292 secondInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
293 addOperationsToInterface(component, secondInterface, 2, 2, true, true, false, false);
294 secondInterface.getOperationsMap().values().stream()
295 .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
297 .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream()
298 .filter(opInputDef -> opInputDef.getName().contains("integer"))
299 .forEach(opInputDef -> opInputDef.setInputId(
300 addedInterfaceType + ".name_for_op_1.output_integer_1")));
301 component.setInterfaces(new HashMap<>());
302 component.getInterfaces().put(addedInterfaceType, addedInterface);
303 component.getInterfaces().put(secondInterfaceType, secondInterface);
305 ToscaNodeType nodeType = new ToscaNodeType();
306 interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
307 Map<String, Object> interfaces = nodeType.getInterfaces();
308 assertNotNull(interfaces);
309 assertEquals(2, interfaces.size());
310 assertTrue(interfaces.containsKey("resourceNameInputMappedToOutput"));
311 Object resourceName = interfaces.get("resourceNameInputMappedToOutput");
312 assertNotNull(resourceName);
313 assertTrue(resourceName instanceof Map);
314 assertEquals(3, ((Map) resourceName).size());
316 assertTrue(interfaces.containsKey("second"));
317 resourceName = interfaces.get("second");
318 assertNotNull(resourceName);
319 assertTrue(resourceName instanceof Map);
320 assertEquals(3, ((Map) resourceName).size());
325 void interfaceWithInputsToscaExportTest() {
326 final Component component = new Service();
327 final InterfaceDefinition anInterfaceWithInput = new InterfaceDefinition();
328 final String interfaceName = "myInterfaceName";
329 final String interfaceType = "my.type." + interfaceName;
330 anInterfaceWithInput.setType(interfaceType);
331 final String input1Name = "input1";
332 final InputDataDefinition input1 = createInput("string", "input1 description", false, "input1 value");
333 final String input2Name = "input2";
334 final InputDataDefinition input2 = createInput("string", "input2 description", true, "input2 value");
335 final Map<String, InputDataDefinition> inputMap = new HashMap<>();
336 inputMap.put(input1Name, input1);
337 inputMap.put(input2Name, input2);
338 anInterfaceWithInput.setInputs(inputMap);
339 component.setInterfaces(new HashMap<>());
340 component.getInterfaces().put(interfaceName, anInterfaceWithInput);
341 final ToscaNodeType nodeType = new ToscaNodeType();
342 interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
343 Map<String, Object> interfaces = nodeType.getInterfaces();
344 assertNotNull(interfaces);
345 assertEquals(1, interfaces.size());
346 assertTrue(interfaces.containsKey("myInterfaceName"));
347 Object resourceName = interfaces.get("myInterfaceName");
348 assertNotNull(resourceName);
349 assertTrue(resourceName instanceof Map);
350 assertEquals(2, ((Map) resourceName).size());
355 void interfaceWithOperationImplementationArtifactPropertiesTest() {
357 final Component component = new Service();
358 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
359 final String interfaceName = "myInterfaceName";
360 interfaceDefinition.setType("my.type." + interfaceName);
361 final var operation1DataDefinition = new OperationDataDefinition();
362 operation1DataDefinition.setName("anOperation");
364 final PropertyDataDefinition listOfStringProperty = new PropertyDataDefinition();
365 listOfStringProperty.setName("listProperty");
366 listOfStringProperty.setType(ToscaType.LIST.getType());
367 final PropertyDataDefinition listOfStringSchemaProperty = new PropertyDataDefinition();
368 listOfStringSchemaProperty.setType(ToscaType.STRING.getType());
369 final SchemaDefinition listPropertySchema = new SchemaDefinition();
370 listPropertySchema.setProperty(listOfStringProperty);
371 listOfStringProperty.setSchema(listPropertySchema);
372 listOfStringProperty.setValue("[ \"value1\", \"value2\", \"value3\" ]");
373 final ArrayList<Object> propertyList = new ArrayList<>();
374 propertyList.add(listOfStringProperty);
375 final HashMap<String, Object> artifactDefinitionMapInitializer = new HashMap<>();
376 artifactDefinitionMapInitializer.put(JsonPresentationFields.PROPERTIES.getPresentation(), propertyList);
377 final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition(artifactDefinitionMapInitializer);
378 artifactDataDefinition.setArtifactName("artifact1");
379 artifactDataDefinition.setArtifactType("my.artifact.Type");
380 operation1DataDefinition.setImplementation(artifactDataDefinition);
381 interfaceDefinition.setOperations(Map.of(operation1DataDefinition.getName(), operation1DataDefinition));
382 component.setInterfaces(new HashMap<>());
383 component.getInterfaces().put(interfaceName, interfaceDefinition);
385 Map<String, Object> interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), null, false);
387 assertTrue(interfacesMap.containsKey(interfaceName));
388 final Map<String, Object> actualInterfaceMap = (Map<String, Object>) interfacesMap.get(interfaceName);
389 assertTrue(actualInterfaceMap.containsKey(operation1DataDefinition.getName()));
390 final Map<String, Object> actualOperationMap = (Map<String, Object>) actualInterfaceMap.get(operation1DataDefinition.getName());
391 assertTrue(actualOperationMap.containsKey("implementation"));
392 final Map<String, Object> actualImplementationMap = (Map<String, Object>) actualOperationMap.get("implementation");
393 assertTrue(actualImplementationMap.containsKey("primary"));
394 final Map<String, Object> actualArtifactImplementationMap = (Map<String, Object>) actualImplementationMap.get("primary");
395 assertTrue(actualArtifactImplementationMap.containsKey("properties"));
396 final Map<String, Object> actualArtifactPropertiesMap = (Map<String, Object>) actualArtifactImplementationMap.get("properties");
397 assertEquals(1, actualArtifactPropertiesMap.keySet().size());
398 assertTrue(actualArtifactPropertiesMap.containsKey(listOfStringProperty.getName()));
399 final Object expectedListObject = actualArtifactPropertiesMap.get(listOfStringProperty.getName());
400 assertTrue(expectedListObject instanceof List);
401 final List<String> expectedListOfStringPropValue = (List<String>) expectedListObject;
402 assertEquals(3, expectedListOfStringPropValue.size());
403 assertTrue(expectedListOfStringPropValue.contains("value1"));
404 assertTrue(expectedListOfStringPropValue.contains("value2"));
405 assertTrue(expectedListOfStringPropValue.contains("value3"));
408 private void addOperationsToInterface(Component component, InterfaceDefinition addedInterface, int numOfOps, int numOfInputsPerOp,
409 boolean hasInputs, boolean hasOutputs, boolean addAComplexType, boolean hasMilestones) {
411 addedInterface.setOperations(new HashMap<>());
412 for (int i = 0; i < numOfOps; i++) {
413 final OperationDataDefinition operation = new OperationDataDefinition();
414 operation.setName("name_for_op_" + i);
415 operation.setDescription("op " + i + " has description");
416 final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
417 implementation.setArtifactName(i + "_createBPMN.bpmn");
418 operation.setImplementation(implementation);
420 operation.setMilestones(createMilestones());
423 operation.setInputs(createInputs(component, numOfInputsPerOp, addAComplexType));
426 operation.setOutputs(createOutputs(addedInterface.getToscaResourceName(),
427 operation.getName(), numOfInputsPerOp));
429 addedInterface.getOperations().put(operation.getName(), operation);
433 private Map<String, MilestoneDataDefinition> createMilestones() {
434 Map<String, MilestoneDataDefinition> toscaMilestones = new HashMap<>();
435 OperationInputDefinition input1 = new OperationInputDefinition();
436 input1.setValue("testString");
437 input1.setType("string");
438 input1.setName("stringName");
439 OperationInputDefinition input2 = createMockComplexOperationInputDefinition("complex", "complex");
440 ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
443 ActivityDataDefinition activity = new ActivityDataDefinition();
444 activity.setType(ActivityTypeEnum.DELEGATE.getValue());
445 activity.setWorkflow("workflow1");
446 activity.setInputs(inputs);
447 ListDataDefinition<ActivityDataDefinition> activities = new ListDataDefinition<>();
448 activities.add(activity);
449 MilestoneDataDefinition milestone = new MilestoneDataDefinition();
450 milestone.setActivities(activities);
451 FilterDataDefinition filter1 = new FilterDataDefinition();
452 filter1.setName("my_attribute");
453 filter1.setConstraint("equal");
454 filter1.setFilterValue("my_value");
455 FilterDataDefinition filter2 = new FilterDataDefinition();
456 ToscaGetFunctionDataDefinition toscaFunction = new ToscaGetFunctionDataDefinition();
457 toscaFunction.setFunctionType(ToscaGetFunctionType.GET_ATTRIBUTE);
458 toscaFunction.setPropertyName("role");
459 toscaFunction.setPropertySource(PropertySource.SELF);
460 toscaFunction.setSourceName("myVfc");
461 toscaFunction.setPropertyPathFromSource(Arrays.asList("role"));
462 filter2.setToscaFunction(toscaFunction);
463 filter2.setName("my_other_attribute");
464 filter2.setConstraint("equal");
465 filter2.setFilterValue("{'get_attribute':['SELF','role']}");
466 ListDataDefinition<FilterDataDefinition> filters = new ListDataDefinition<>();
467 filters.add(filter1);
468 filters.add(filter2);
469 milestone.setFilters(filters);
470 toscaMilestones.put(MilestoneTypeEnum.ON_ENTRY.getValue(), milestone);
471 return toscaMilestones;
474 private InputDataDefinition createInput(final String type, final String description, final Boolean isRequired,
475 final String defaultValue) {
476 final PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
478 propertyDataDefinition.setType(type);
480 if (description != null) {
481 propertyDataDefinition.setDescription(description);
483 if (defaultValue != null) {
484 propertyDataDefinition.setDefaultValue(defaultValue);
486 if (isRequired != null) {
487 propertyDataDefinition.setRequired(isRequired);
489 return new InputDataDefinition(propertyDataDefinition);
492 private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs, boolean addAComplexType) {
493 ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
494 if (addAComplexType) {
495 String mappedPropertyName = java.util.UUID.randomUUID() + "." + MAPPED_PROPERTY_NAME + numOfInputs;
496 operationInputDefinitionList.add(
497 createMockComplexOperationInputDefinition(INPUT_NAME_PREFIX + "Complex" + "_" + numOfInputs, mappedPropertyName));
500 for (int i = 0; i < numOfInputs; i++) {
501 String mappedPropertyName = java.util.UUID.randomUUID() + "." + MAPPED_PROPERTY_NAME + i;
502 operationInputDefinitionList.add(createMockOperationInputDefinition(
503 INPUT_NAME_PREFIX + inputTypes[i] + "_" + i, mappedPropertyName, i));
504 addMappedPropertyAsComponentInput(component, mappedPropertyName);
507 return operationInputDefinitionList;
510 private void addMappedPropertyAsComponentInput(Component component, String mappedPropertyName) {
511 InputDefinition componentInput = new InputDefinition();
512 componentInput.setUniqueId(mappedPropertyName.split("\\.")[0]);
513 componentInput.setName(mappedPropertyName.split("\\.")[1]);
514 if (Objects.isNull(component.getInputs())) {
515 component.setInputs(new ArrayList<>());
517 component.getInputs().add(componentInput);
520 private ListDataDefinition<OperationOutputDefinition> createOutputs(String interfaceName,
521 String operationName,
523 ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
524 for (int i = 0; i < numOfOutputs; i++) {
525 operationOutputDefinitionList.add(createMockOperationOutputDefinition(interfaceName, operationName,
526 OUTPUT_NAME_PREFIX + inputTypes[i] + "_" + i, i));
528 return operationOutputDefinitionList;
531 private OperationInputDefinition createMockOperationInputDefinition(String name, String id, int index) {
532 OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
533 operationInputDefinition.setName(name);
534 operationInputDefinition.setInputId(id);
535 operationInputDefinition.setType(inputTypes[index]);
536 operationInputDefinition.setRequired(index % 2 == 0);
537 Map<String, List<String>> toscaDefaultValueMap = new HashMap<>();
538 List<String> toscaDefaultValues = new ArrayList<>();
539 toscaDefaultValues.add(SELF);
540 toscaDefaultValues.add(id.substring(id.lastIndexOf('.') + 1));
541 toscaDefaultValueMap.put(ToscaFunctions.GET_PROPERTY.getFunctionName(), toscaDefaultValues);
542 operationInputDefinition.setToscaDefaultValue(new Gson().toJson(toscaDefaultValueMap));
543 operationInputDefinition.setSource("ServiceInput");
544 return operationInputDefinition;
547 private OperationInputDefinition createMockComplexOperationInputDefinition(String name, String id) {
548 OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
549 operationInputDefinition.setName(name);
550 operationInputDefinition.setInputId(id);
551 operationInputDefinition.setType("complexDataType");
552 operationInputDefinition.setRequired(false);
553 operationInputDefinition.setValue(
554 "{\"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\"]}}");
555 return operationInputDefinition;
558 private OperationOutputDefinition createMockOperationOutputDefinition(String interfaceName, String operationName,
559 String outputName, int index) {
560 OperationOutputDefinition operationInputDefinition = new OperationOutputDefinition();
561 operationInputDefinition.setName(outputName);
562 operationInputDefinition.setType(inputTypes[index]);
563 operationInputDefinition.setRequired(index % 2 == 0);
564 List<String> toscaDefaultValues = new ArrayList<>();
565 toscaDefaultValues.add(SELF);
566 toscaDefaultValues.add(interfaceName);
567 toscaDefaultValues.add(operationName);
568 toscaDefaultValues.add(outputName);
569 Map<String, List<String>> toscaDefaultValueMap = new HashMap<>();
570 toscaDefaultValueMap.put(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName(), toscaDefaultValues);
571 return operationInputDefinition;
575 void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() {
576 Service service = new Service();
577 service.setComponentMetadataDefinition(new ServiceMetadataDefinition());
578 service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface");
579 service.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("LocalInterface");
580 service.setInterfaces(Collections.singletonMap("Local", new InterfaceDefinition("Local", null, new HashMap<>())));
582 Map<String, Object> resultMap = interfacesOperationsConverter.addInterfaceTypeElement(service,
583 Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard"));
585 assertTrue(MapUtils.isNotEmpty(resultMap)
586 && resultMap.containsKey("org.openecomp.interfaces.node.lifecycle.LocalInterface"));
590 void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() {
591 Service service = new Service();
592 service.setComponentMetadataDefinition(new ServiceMetadataDefinition());
593 service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface");
594 service.setInterfaces(Collections.singletonMap("NotLocal", new InterfaceDefinition("NotLocal", null,
597 Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null, service.getInterfaces(), null, false);
599 assertTrue(MapUtils.isNotEmpty(resultMap)
600 && resultMap.containsKey("NotLocal"));
604 void testGetInterfaceAsMapWithComplexType() {
605 addComplexTypeToDataTypes();
606 Component component = new Resource();
607 component.setNormalizedName("normalizedComponentName");
608 InterfaceDefinition addedInterface = new InterfaceDefinition();
609 addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
610 addedInterface.setType("com.some.resource.or.other.resourceName");
611 addOperationsToInterface(component, addedInterface, 3, 2, true, false, true, false);
612 final String interfaceType = "normalizedComponentName-interface";
613 component.setInterfaces(new HashMap<>());
614 component.getInterfaces().put(interfaceType, addedInterface);
615 final var interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), dataTypes, false);
616 assertNotNull(interfacesMap);
617 assertEquals(1, interfacesMap.size());
618 assertTrue(interfacesMap.containsKey("resourceName"));
619 Object resourceName = interfacesMap.get("resourceName");
620 assertNotNull(resourceName);
621 assertTrue(resourceName instanceof Map);
622 assertEquals(4, ((Map) resourceName).size());
623 assertTrue(resourceName instanceof Map);
624 Map<String, Object> resource = (Map<String, Object>) resourceName;
625 assertTrue(resource.containsKey("name_for_op_0"));
626 Map<String, Object> operation0 = (Map<String, Object>) resource.get("name_for_op_0");
627 assertTrue(operation0.containsKey("inputs"));
628 Map<String, Object> operation0Inputs = (Map<String, Object>) operation0.get("inputs");
629 assertTrue(operation0Inputs.containsKey("input_Complex_2"));
630 Map<String, Object> complexInput = (Map<String, Object>) operation0Inputs.get("input_Complex_2");
631 assertTrue(complexInput.containsKey("stringProp"));
632 Map<String, Object> complexInputStringProp = (Map<String, Object>) complexInput.get("stringProp");
633 assertTrue(complexInputStringProp.containsKey("type"));
634 assertTrue(ToscaFunctionType.findType((String) complexInputStringProp.get("type")).isPresent());
635 assertTrue(complexInputStringProp.containsKey("propertyName"));
636 assertEquals("designer", complexInputStringProp.get("propertyName"));
637 assertTrue(complexInputStringProp.containsKey("propertySource"));
638 assertEquals("SELF", complexInputStringProp.get("propertySource"));
642 void testGetInterfaceAsMapWithMilestones() {
643 addComplexTypeToDataTypes();
644 Component component = new Resource();
645 component.setNormalizedName("normalizedComponentName");
646 InterfaceDefinition addedInterface = new InterfaceDefinition();
647 addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
648 addedInterface.setType("com.some.resource.or.other.resourceName");
649 addOperationsToInterface(component, addedInterface, 2, 0, false, false, false, true);
650 final String interfaceType = "normalizedComponentName-interface";
651 component.setInterfaces(new HashMap<>());
652 component.getInterfaces().put(interfaceType, addedInterface);
653 final var interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), dataTypes, false);
654 assertNotNull(interfacesMap);
655 assertEquals(1, interfacesMap.size());
656 assertTrue(interfacesMap.containsKey("resourceName"));
657 Object resourceName = interfacesMap.get("resourceName");
658 assertNotNull(resourceName);
659 assertTrue(resourceName instanceof Map);
660 assertEquals(3, ((Map) resourceName).size());
661 Map<String, Object> resource = (Map<String, Object>) resourceName;
662 assertTrue(resource.containsKey("name_for_op_0"));
663 Map<String, Object> operation0 = (Map<String, Object>) resource.get("name_for_op_0");
664 assertTrue(operation0.containsKey("milestones"));
665 Map<String, Object> operation0Milestones = (Map<String, Object>) operation0.get("milestones");
666 assertTrue(operation0Milestones.containsKey(MilestoneTypeEnum.ON_ENTRY.getValue()));
667 Map<String, Object> milestone = (Map<String, Object>) operation0Milestones.get(MilestoneTypeEnum.ON_ENTRY.getValue());
668 assertTrue(milestone.containsKey("activities"));
669 List<Map<String, Object>> activities = (List<Map<String, Object>>) milestone.get("activities");
670 assertEquals(1, activities.size());
671 Map<String, Object> activity = activities.get(0);
672 assertEquals(1, activities.size());
673 assertTrue(activity.containsKey("delegate"));
674 Map<String, Object> activityVariables = (Map<String, Object>) activity.get("delegate");
675 assertTrue(activityVariables.containsKey("workflow"));
676 assertEquals("workflow1", activityVariables.get("workflow"));
677 assertTrue(activityVariables.containsKey("inputs"));
678 assertTrue(activityVariables.get("inputs") instanceof Map);
679 Map<String, Object> inputs = (Map<String, Object>) activityVariables.get("inputs");
680 assertNotNull(inputs);
681 assertTrue(inputs.containsKey("stringName"));
682 assertTrue(inputs.get("stringName") instanceof String);
683 String input = (String) inputs.get("stringName");
684 assertEquals("testString", input);
685 assertTrue(inputs.containsKey("complex"));
686 Map<String, Object> complexInput = (Map<String, Object>) inputs.get("complex");
687 assertTrue(complexInput.containsKey("intProp"));
688 assertTrue(complexInput.get("intProp") instanceof Integer);
689 assertEquals(1, complexInput.get("intProp"));
690 assertTrue(complexInput.containsKey("stringProp"));
691 Map<String, Object> complexInputStringProp = (Map<String, Object>) complexInput.get("stringProp");
692 assertTrue(complexInputStringProp.containsKey("type"));
693 assertTrue(ToscaFunctionType.findType((String) complexInputStringProp.get("type")).isPresent());
694 assertTrue(complexInputStringProp.containsKey("propertyName"));
695 assertEquals("designer", complexInputStringProp.get("propertyName"));
696 assertTrue(complexInputStringProp.containsKey("propertySource"));
697 assertEquals("SELF", complexInputStringProp.get("propertySource"));
699 assertTrue(milestone.containsKey("filters"));
700 List<Map<String, Object>> filters = (List<Map<String, Object>>) milestone.get("filters");
701 assertEquals(2, filters.size());
702 Map<String, Object> filter1 = filters.get(0);
703 assertTrue(filter1.containsKey("my_attribute"));
704 Map<String, Object> filter1Constraint = (Map<String, Object>) filter1.get("my_attribute");
705 assertTrue(filter1Constraint.containsKey(ConstraintType.EQUAL.getType()));
706 String filter1Value = (String) filter1Constraint.get(ConstraintType.EQUAL.getType());
707 assertEquals("my_value", filter1Value);
708 Map<String, Object> filter2 = filters.get(1);
709 assertTrue(filter2.containsKey("my_other_attribute"));
710 Map<String, Object> filter2Constraint = (Map<String, Object>) filter2.get("my_other_attribute");
711 assertTrue(filter2Constraint.containsKey(ConstraintType.EQUAL.getType()));
712 Map<String, Object> filter2Value = (Map<String, Object>) filter2Constraint.get(ConstraintType.EQUAL.getType());
713 assertTrue(filter2Value.containsKey(ToscaGetFunctionType.GET_ATTRIBUTE.getFunctionName()));
714 List<String> filter2ValueToscaFunction = (List<String>) filter2Value.get(ToscaGetFunctionType.GET_ATTRIBUTE.getFunctionName());
715 assertEquals(2, filter2ValueToscaFunction.size());
716 assertEquals("SELF", filter2ValueToscaFunction.get(0));
717 assertEquals("role", filter2ValueToscaFunction.get(1));
720 private void addComplexTypeToDataTypes() {
721 PropertyDefinition intProp = new PropertyDefinition();
722 intProp.setType("integer");
723 intProp.setName("intProp");
724 PropertyDefinition stringProp = new PropertyDefinition();
725 stringProp.setType("string");
726 stringProp.setName("stringProp");
727 DataTypeDefinition dataType = new DataTypeDefinition();
728 dataType.setName("complexDataType");
729 dataType.setProperties(new ArrayList<>(Arrays.asList(stringProp, intProp)));
730 dataTypes.put("complexDataType", dataType);
734 void testRemoveInterfacesWithoutOperationsEmptyMap() {
735 final Map<String, Object> interfaceMap = new HashMap<>();
736 interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
737 assertNotNull(interfaceMap);
738 assertTrue(interfaceMap.isEmpty());
742 void testRemoveInterfacesWithoutOperationsNullParameter() {
743 final Map<String, Object> interfaceMap = null;
744 interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
745 assertNull(interfaceMap);
749 void testRemoveInterfacesWithoutOperationsSuccess() {
750 final Map<String, Object> interfaceMap = new HashMap<>();
751 final ToscaInterfaceDefinition toscaInterfaceDefinition1 = new ToscaInterfaceDefinition();
752 interfaceMap.put("toscaInterfaceDefinition1", toscaInterfaceDefinition1);
754 final ToscaInterfaceDefinition toscaInterfaceDefinition2 = new ToscaInterfaceDefinition();
755 final Map<String, Object> toscaInterfaceDefinition2OperationMap = new HashMap<>();
756 toscaInterfaceDefinition2OperationMap.put("operation1", new Object());
757 toscaInterfaceDefinition2.setOperations(toscaInterfaceDefinition2OperationMap);
758 interfaceMap.put("toscaInterfaceDefinition2", toscaInterfaceDefinition2);
760 final Map<String, Object> toscaInterfaceDefinition3 = new HashMap<>();
761 interfaceMap.put("toscaInterfaceDefinition3", toscaInterfaceDefinition3);
763 final Map<String, Object> toscaInterfaceDefinition4 = new HashMap<>();
764 toscaInterfaceDefinition4.put("operation1", new Object());
765 interfaceMap.put("toscaInterfaceDefinition4", toscaInterfaceDefinition4);
767 final Object notAToscaInterfaceDefinition = new Object();
768 interfaceMap.put("notAToscaInterfaceDefinition", notAToscaInterfaceDefinition);
770 interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
771 assertFalse(interfaceMap.containsKey("toscaInterfaceDefinition1"));
772 assertTrue(interfaceMap.containsKey("toscaInterfaceDefinition2"));
773 assertFalse(interfaceMap.containsKey("toscaInterfaceDefinition3"));
774 assertTrue(interfaceMap.containsKey("toscaInterfaceDefinition4"));
775 assertTrue(interfaceMap.containsKey("notAToscaInterfaceDefinition"));