catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java

   1 /*
   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
   8  *
   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.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.openecomp.sdc.be.tosca;
  21
  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;
  29
  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;
  38 import java.util.Map;
  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;
  76
  77 class InterfacesOperationsConverterTest {
  78
  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;
  87
  88     @BeforeAll
  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);
  94     }
  95
  96     @BeforeEach
  97     public void setUpBeforeTest() {
  98         interfacesOperationsConverter = new InterfacesOperationsConverter(new PropertyConvertor());
  99     }
 100
 101     @Test
 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");
 118         assertNotNull(o);
 119         assertTrue(o instanceof Map);
 120         assertEquals(7, ((Map) o).size());
 121
 122     }
 123
 124     @Test
 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");
 141         assertNotNull(o);
 142         assertTrue(o instanceof Map);
 143         assertEquals(7, ((Map) o).size());
 144
 145     }
 146
 147     @Test
 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");
 153
 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());
 168
 169     }
 170
 171     @Test
 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());
 191
 192     }
 193
 194     @Test
 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());
 213
 214     }
 215
 216     @Test
 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());
 236
 237     }
 238
 239     @Test
 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(
 249                 "name_for_op_0"))
 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())));
 256                 }));
 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());
 269
 270     }
 271
 272     @Test
 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(
 283                 "name_for_op_0"))
 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(
 296                 "name_for_op_0"))
 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);
 304
 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());
 315
 316         assertTrue(interfaces.containsKey("second"));
 317         resourceName = interfaces.get("second");
 318         assertNotNull(resourceName);
 319         assertTrue(resourceName instanceof Map);
 320         assertEquals(3, ((Map) resourceName).size());
 321
 322     }
 323
 324     @Test
 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());
 351
 352     }
 353
 354     @Test
 355     void interfaceWithOperationImplementationArtifactPropertiesTest() {
 356         //given
 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");
 363
 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);
 384         //when
 385         Map<String, Object> interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), null, false);
 386         //then
 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"));
 406     }
 407
 408     private void addOperationsToInterface(Component component, InterfaceDefinition addedInterface, int numOfOps, int numOfInputsPerOp,
 409                                           boolean hasInputs, boolean hasOutputs, boolean addAComplexType, boolean hasMilestones) {
 410
 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);
 419             if (hasMilestones) {
 420                 operation.setMilestones(createMilestones());
 421             }
 422             if (hasInputs) {
 423                 operation.setInputs(createInputs(component, numOfInputsPerOp, addAComplexType));
 424             }
 425             if (hasOutputs) {
 426                 operation.setOutputs(createOutputs(addedInterface.getToscaResourceName(),
 427                     operation.getName(), numOfInputsPerOp));
 428             }
 429             addedInterface.getOperations().put(operation.getName(), operation);
 430         }
 431     }
 432
 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<>();
 441         inputs.add(input1);
 442         inputs.add(input2);
 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;
 472     }
 473
 474     private InputDataDefinition createInput(final String type, final String description, final Boolean isRequired,
 475                                             final String defaultValue) {
 476         final PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 477         if (type != null) {
 478             propertyDataDefinition.setType(type);
 479         }
 480         if (description != null) {
 481             propertyDataDefinition.setDescription(description);
 482         }
 483         if (defaultValue != null) {
 484             propertyDataDefinition.setDefaultValue(defaultValue);
 485         }
 486         if (isRequired != null) {
 487             propertyDataDefinition.setRequired(isRequired);
 488         }
 489         return new InputDataDefinition(propertyDataDefinition);
 490     }
 491
 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));
 498             numOfInputs -= 1;
 499         }
 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);
 505
 506         }
 507         return operationInputDefinitionList;
 508     }
 509
 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<>());
 516         }
 517         component.getInputs().add(componentInput);
 518     }
 519
 520     private ListDataDefinition<OperationOutputDefinition> createOutputs(String interfaceName,
 521                                                                         String operationName,
 522                                                                         int numOfOutputs) {
 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));
 527         }
 528         return operationOutputDefinitionList;
 529     }
 530
 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;
 545     }
 546
 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;
 556     }
 557
 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;
 572     }
 573
 574     @Test
 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<>())));
 581
 582         Map<String, Object> resultMap = interfacesOperationsConverter.addInterfaceTypeElement(service,
 583             Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard"));
 584
 585         assertTrue(MapUtils.isNotEmpty(resultMap)
 586             && resultMap.containsKey("org.openecomp.interfaces.node.lifecycle.LocalInterface"));
 587     }
 588
 589     @Test
 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,
 595             new HashMap<>())));
 596
 597         Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null, service.getInterfaces(), null, false);
 598
 599         assertTrue(MapUtils.isNotEmpty(resultMap)
 600             && resultMap.containsKey("NotLocal"));
 601     }
 602
 603     @Test
 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"));
 639     }
 640
 641     @Test
 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"));
 698
 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));
 718     }
 719
 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);
 731     }
 732
 733     @Test
 734     void testRemoveInterfacesWithoutOperationsEmptyMap() {
 735         final Map<String, Object> interfaceMap = new HashMap<>();
 736         interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
 737         assertNotNull(interfaceMap);
 738         assertTrue(interfaceMap.isEmpty());
 739     }
 740
 741     @Test
 742     void testRemoveInterfacesWithoutOperationsNullParameter() {
 743         final Map<String, Object> interfaceMap = null;
 744         interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
 745         assertNull(interfaceMap);
 746     }
 747
 748     @Test
 749     void testRemoveInterfacesWithoutOperationsSuccess() {
 750         final Map<String, Object> interfaceMap = new HashMap<>();
 751         final ToscaInterfaceDefinition toscaInterfaceDefinition1 = new ToscaInterfaceDefinition();
 752         interfaceMap.put("toscaInterfaceDefinition1", toscaInterfaceDefinition1);
 753
 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);
 759
 760         final Map<String, Object> toscaInterfaceDefinition3 = new HashMap<>();
 761         interfaceMap.put("toscaInterfaceDefinition3", toscaInterfaceDefinition3);
 762
 763         final Map<String, Object> toscaInterfaceDefinition4 = new HashMap<>();
 764         toscaInterfaceDefinition4.put("operation1", new Object());
 765         interfaceMap.put("toscaInterfaceDefinition4", toscaInterfaceDefinition4);
 766
 767         final Object notAToscaInterfaceDefinition = new Object();
 768         interfaceMap.put("notAToscaInterfaceDefinition", notAToscaInterfaceDefinition);
 769
 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"));
 776     }
 777 }