gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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
  17 package org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata;
  18
  19 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.MAIN_SERVICE_TEMPLATE;
  20 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_DEPENDS_ON_INVALID_DEPENDENCY_CANDIDATE;
  21 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_DEPENDS_ON_MULTIPLE_COMPUTE;
  22 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_DEPENDS_ON_NODES_CONNECTED_IN;
  23 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_DEPENDS_ON_NODES_CONNECTED_IN_AND_OUT;
  24 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_DEPENDS_ON_NODES_CONNECTED_OUT;
  25 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_DEPENDS_ON_NO_DEPENDENCY;
  26 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_MULTIPLE_MULTI_LEVEL_NESTED_RESOURCE;
  27 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_MULTIPLE_NESTED_RESOURCE;
  28 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_SECURITY_RULE_PORT_MULTI_LEVEL_NESTED_CONNECTION;
  29 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_SECURITY_RULE_PORT_MULTI_LEVEL_NESTED_SHARED_PORT;
  30 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_SECURITY_RULE_PORT_NESTED_CONNECTION;
  31 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.TestConstants.TEST_SINGLE_NESTED_RESOURCE;
  32
  33 import com.fasterxml.jackson.databind.ObjectMapper;
  34  import com.google.common.collect.ArrayListMultimap;
  35 import com.google.common.collect.Multimap;
  36
  37 import org.apache.commons.collections4.CollectionUtils;
  38 import org.junit.Assert;
  39 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  40 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  41 import org.onap.sdc.tosca.datatypes.model.GroupDefinition;
  42 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  43 import org.onap.sdc.tosca.datatypes.model.NodeType;
  44 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  45 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  46 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  47 import org.openecomp.sdc.tosca.services.DataModelUtil;
  48 import org.openecomp.sdc.tosca.services.ToscaConstants;
  49 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  50 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  51 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  52 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  53 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
  54 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  55 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData;
  56 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  57 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  58 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  59 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
  60 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  61
  62 import java.util.ArrayList;
  63 import java.util.Collection;
  64 import java.util.HashMap;
  65 import java.util.Iterator;
  66 import java.util.LinkedHashMap;
  67 import java.util.LinkedList;
  68 import java.util.List;
  69 import java.util.Map;
  70 import java.util.Objects;
  71 import java.util.Optional;
  72 import java.util.Set;
  73
  74 public class ConsolidationDataTestUtil {
  75
  76   public static void validateVolumeInConsolidationData(String computeNodeTemplateId,
  77                                                        ComputeTemplateConsolidationData
  78                                                            computeTemplateConsolidationData,
  79                                                        ServiceTemplate expectedServiceTemplate,
  80                                                        String testName) {
  81     Assert.assertNotNull(computeTemplateConsolidationData);
  82     //Get the volume information from consolidation data
  83     Multimap<String, RequirementAssignmentData> volumeConsolidationData =
  84         computeTemplateConsolidationData.getVolumes();
  85
  86     if(testName.equals("Negative")) {
  87       Assert.assertNull(volumeConsolidationData);
  88       return;
  89     }
  90
  91     //Get the volume requirement information from the output translated template
  92     NodeTemplate computeNode = DataModelUtil.getNodeTemplate(expectedServiceTemplate,
  93         computeNodeTemplateId);
  94
  95     if(!isComputeNodeType(expectedServiceTemplate, computeNode.getType()) ) {
  96       //According to toplogy only Compute->volume relationship is valid
  97       Assert.assertNull(volumeConsolidationData);
  98       return;
  99     }
 100
 101     Assert.assertNotNull(computeNode);
 102     List<String> computeVolumeRequirementsNodes = new ArrayList<>();
 103     List<Map<String, RequirementAssignment>> requirementList = computeNode.getRequirements();
 104     if(requirementList != null){
 105       for(Map<String, RequirementAssignment> req : requirementList){
 106         Set<String> reqKeySet = req.keySet();
 107         for(String reqKey : reqKeySet){
 108           //populating the "node" property of all the requirements "local_storage" related to volume
 109           if(reqKey.equals(ToscaConstants.LOCAL_STORAGE_REQUIREMENT_ID)){
 110             RequirementAssignment requirementAssignment = new ObjectMapper().convertValue(req.get
 111                 (reqKey), RequirementAssignment.class);
 112             computeVolumeRequirementsNodes.add(requirementAssignment.getNode());
 113           }
 114         }
 115       }
 116       isVolumeComputeRequirement(computeVolumeRequirementsNodes, volumeConsolidationData);
 117     }
 118   }
 119
 120     private static void isVolumeComputeRequirement(List<String> computeVolumeRequirementsNodes,
 121                                                    Multimap<String, RequirementAssignmentData>
 122                                                            volumeConsolidationData) {
 123         Assert.assertEquals(computeVolumeRequirementsNodes.size(), volumeConsolidationData.size());
 124         for (String volumeNodeTemplateId : computeVolumeRequirementsNodes) {
 125             Assert.assertNotNull(volumeConsolidationData.containsKey(volumeNodeTemplateId));
 126             Collection<RequirementAssignmentData> requirementAssignmentDataList = volumeConsolidationData.get
 127                     (volumeNodeTemplateId);
 128             for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
 129                 Assert.assertTrue(requirementAssignmentData.getRequirementId().equals(ToscaConstants
 130                         .LOCAL_STORAGE_REQUIREMENT_ID));
 131             }
 132         }
 133     }
 134
 135
 136   public static void validatePortsInConsolidationData(String computeNodeTemplateId,
 137                                                       ComputeTemplateConsolidationData
 138                                                           computeTemplateConsolidationData,
 139                                                       ServiceTemplate outputServiceTemplate){
 140     Map<String,List<String>> consolidatedMap = computeTemplateConsolidationData.getPorts();
 141     Map<String,List<String>> expectedMap = getPortsInConsolidationData(outputServiceTemplate).get
 142         (computeNodeTemplateId);
 143     if(expectedMap == null && consolidatedMap == null){
 144       return;
 145     }
 146     for(String consolidatedKey : consolidatedMap.keySet()){
 147       List<String> consolidatedList = consolidatedMap.get(consolidatedKey);
 148       if (expectedMap != null) {
 149         List<String> expectedList = expectedMap.get(consolidatedKey);
 150         if (expectedList == null) {
 151           Assert.fail();
 152         }
 153         if (!CollectionUtils.isEqualCollection(consolidatedList, expectedList)) {
 154           Assert.fail();
 155         }
 156       }
 157     }
 158   }
 159
 160     public static void validateDependsOnInConsolidationData(String computeNodeTemplateId,
 161                                                             ComputeTemplateConsolidationData
 162                                                                     computeTemplateConsolidationData,
 163                                                             ServiceTemplate outputServiceTemplate,
 164                                                             String testName) {
 165         Map<String, NodeTemplate> outputNodeTemplates = outputServiceTemplate.getTopology_template()
 166                 .getNode_templates();
 167         Multimap<String, RequirementAssignmentData> nodesConnectedIn =
 168                 computeTemplateConsolidationData.getNodesConnectedIn();
 169         Multimap<String, RequirementAssignmentData> nodesConnectedOut =
 170                 computeTemplateConsolidationData.getNodesConnectedOut();
 171
 172         if (testName.equals(TEST_DEPENDS_ON_INVALID_DEPENDENCY_CANDIDATE) ||
 173                 testName.equals(TEST_DEPENDS_ON_NO_DEPENDENCY)) {
 174             Assert.assertNull(nodesConnectedIn);
 175             Assert.assertNull(nodesConnectedOut);
 176             return;
 177         }
 178         //key - nodetemplate id , value - requirementassignment
 179         Multimap<String, RequirementAssignment> outputDependsOnNodeRequirementMap = ArrayListMultimap.create();
 180         for (Map.Entry<String, NodeTemplate> entry : outputNodeTemplates.entrySet()) {
 181             NodeTemplate nodeTemplate = entry.getValue();
 182             List<Map<String, RequirementAssignment>> nodeRequirements = nodeTemplate.getRequirements();
 183             if (nodeRequirements != null) {
 184                 for (Map<String, RequirementAssignment> req : nodeRequirements) {
 185                     Set<String> keySet = req.keySet();
 186                     for (String key : keySet) {
 187                         if (key.equals(ToscaConstants.DEPENDS_ON_REQUIREMENT_ID))
 188                         //collect all dependency requirements in a map with key -> node template id
 189                         {
 190                             outputDependsOnNodeRequirementMap.put(entry.getKey(), req.get(key));
 191                         }
 192                     }
 193                 }
 194             }
 195         }
 196
 197         if (testName.equals(TEST_DEPENDS_ON_NODES_CONNECTED_OUT)) {
 198             Assert.assertNull(nodesConnectedIn);
 199             validateDependsOnNodesConnectedOut(computeNodeTemplateId, nodesConnectedOut,
 200                     outputDependsOnNodeRequirementMap, outputServiceTemplate);
 201         }
 202
 203         if (testName.equals(TEST_DEPENDS_ON_NODES_CONNECTED_IN)) {
 204             Assert.assertNull(nodesConnectedOut);
 205             validateDependsOnNodesConnectedIn(computeNodeTemplateId, nodesConnectedIn,
 206                     outputDependsOnNodeRequirementMap,
 207                     outputServiceTemplate);
 208         }
 209
 210         if (testName.equals(TEST_DEPENDS_ON_NODES_CONNECTED_IN_AND_OUT)) {
 211             Assert.assertNotNull(nodesConnectedIn);
 212             Assert.assertNotNull(nodesConnectedOut);
 213             validateDependsOnNodesConnectedOut(computeNodeTemplateId, nodesConnectedOut,
 214                     outputDependsOnNodeRequirementMap,
 215                     outputServiceTemplate);
 216             validateDependsOnNodesConnectedIn(computeNodeTemplateId, nodesConnectedIn,
 217                     outputDependsOnNodeRequirementMap,
 218                     outputServiceTemplate);
 219         }
 220
 221         if (testName.equals(TEST_DEPENDS_ON_MULTIPLE_COMPUTE)) {
 222             if (nodesConnectedOut != null) {
 223                 validateDependsOnNodesConnectedOut(computeNodeTemplateId, nodesConnectedOut,
 224                         outputDependsOnNodeRequirementMap,
 225                         outputServiceTemplate);
 226             }
 227             if (nodesConnectedIn != null) {
 228                 validateDependsOnNodesConnectedIn(computeNodeTemplateId, nodesConnectedIn,
 229                         outputDependsOnNodeRequirementMap,
 230                         outputServiceTemplate);
 231             }
 232         }
 233
 234
 235     }
 236
 237   private static void validateDependsOnNodesConnectedIn(String computeNodeTemplateId,
 238                                                         Multimap<String, RequirementAssignmentData>
 239                                                             nodesConnectedIn,
 240                                                         Multimap<String, RequirementAssignment>
 241                                                             outputDependsOnNodeRequirementMap,
 242                                                         ServiceTemplate outputServiceTemplate) {
 243     ToscaAnalyzerServiceImpl analyzerService = new ToscaAnalyzerServiceImpl();
 244     for(String sourceNodeTemplateId : outputDependsOnNodeRequirementMap.keySet()) {
 245       Optional<NodeTemplate> sourceNodeTemplate = analyzerService.getNodeTemplateById
 246           (outputServiceTemplate, sourceNodeTemplateId);
 247       String sourceNodeType = sourceNodeTemplate.get().getType();
 248       for(Object obj : outputDependsOnNodeRequirementMap.get(sourceNodeTemplateId)){
 249         RequirementAssignment req = new ObjectMapper().convertValue(obj, RequirementAssignment
 250             .class);
 251         String targetNodeTemplateId = req.getNode();
 252         Optional<NodeTemplate> targetNodeTemplate = analyzerService.getNodeTemplateById
 253             (outputServiceTemplate, targetNodeTemplateId);
 254
 255         String targetNodeType = targetNodeTemplate.get().getType();
 256         boolean isValidTargetForConnectedIn = false;
 257         if(isComputeNodeType(outputServiceTemplate, targetNodeType)) {
 258           isValidTargetForConnectedIn = true;
 259         } else if(isPortNodeType(outputServiceTemplate, targetNodeType)) {
 260           isValidTargetForConnectedIn = true;
 261         }
 262
 263         if(isValidTargetForConnectedIn) {
 264           //Should be present if target node is compute or port
 265           if(computeNodeTemplateId.equals(sourceNodeTemplateId))
 266             Assert.assertTrue(nodesConnectedIn.containsKey(sourceNodeTemplateId));
 267         }
 268
 269         if(sourceNodeType.startsWith(ToscaNodeType.NOVA_SERVER)
 270             && (targetNodeType.startsWith(ToscaNodeType.NOVA_SERVER)
 271             || targetNodeType.startsWith(ToscaNodeType.NEUTRON_PORT)
 272             || targetNodeType.startsWith(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE))) {
 273           //Ignore Compute->Port, Compute->Compute, Compute->Volume relationship
 274           Assert.assertFalse(nodesConnectedIn.containsKey(targetNodeTemplateId));
 275         }
 276
 277         if(sourceNodeType.startsWith(ToscaNodeType.NEUTRON_PORT)
 278             && (targetNodeType.startsWith(ToscaNodeType.NOVA_SERVER)
 279             || targetNodeType.startsWith(ToscaNodeType.NEUTRON_PORT)
 280             || targetNodeType.startsWith(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE))) {
 281           //Ignore Port->Port, Port->Compute, Port->Volume relationship
 282           Assert.assertFalse(nodesConnectedIn.containsKey(targetNodeTemplateId));
 283         }
 284       }
 285     }
 286   }
 287
 288   private static boolean isComputeNodeType(ServiceTemplate serviceTemplate,
 289                                            String nodeType) {
 290
 291     if(nodeType.equals(ToscaNodeType.NOVA_SERVER) ||
 292         nodeType.equals(ToscaNodeType.NATIVE_COMPUTE))
 293       return true;
 294
 295     Map<String, NodeType> nodeTypes = serviceTemplate.getNode_types();
 296     if(nodeTypes.containsKey(nodeType)) {
 297       NodeType nodeTypeInfo = nodeTypes.get(nodeType);
 298       if(nodeTypeInfo.getDerived_from().equals(ToscaNodeType.NOVA_SERVER))
 299         return true;
 300     }
 301     return false;
 302   }
 303
 304   private static boolean isPortNodeType(ServiceTemplate serviceTemplate,
 305                                         String nodeType) {
 306     if(nodeType.equals(ToscaNodeType.NEUTRON_PORT) ||
 307         nodeType.equals(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE))
 308       return true;
 309
 310     Map<String, NodeType> nodeTypes = serviceTemplate.getNode_types();
 311     if(nodeTypes.containsKey(nodeType)) {
 312       NodeType nodeTypeInfo = nodeTypes.get(nodeType);
 313       if(nodeTypeInfo.getDerived_from().equals(ToscaNodeType.NEUTRON_PORT) ||
 314           nodeTypeInfo.getDerived_from().equals(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE))
 315         return true;
 316     }
 317     return false;
 318   }
 319
 320     private static void validateDependsOnNodesConnectedOut(String computeNodeTemplateId,
 321                                                            Multimap<String, RequirementAssignmentData>
 322                                                                    nodesConnectedOut,
 323                                                            Multimap<String, RequirementAssignment>
 324                                                                    outputDependsOnNodeRequirementMap,
 325                                                            ServiceTemplate outputServiceTemplate) {
 326         ToscaAnalyzerServiceImpl analyzerService = new ToscaAnalyzerServiceImpl();
 327         //Iterating the map <nodeTemplateId, all the requirements of that node>
 328     /*for(Map.Entry<String, List<RequirementAssignment>> entry : outputDependsOnNodeRequirementMap
 329         .entrySet()) {*/
 330         for (String sourceNodeTemplateId : outputDependsOnNodeRequirementMap.keySet()) {
 331             Optional<NodeTemplate> sourceNodeTemplate = analyzerService.getNodeTemplateById
 332                     (outputServiceTemplate, sourceNodeTemplateId);
 333
 334             String sourceNodeType = sourceNodeTemplate.get().getType();
 335             boolean isValidSourceForConnectedOut = false;
 336             if (isComputeNodeType(outputServiceTemplate, sourceNodeType)) {
 337                 isValidSourceForConnectedOut = true;
 338             } else if (isPortNodeType(outputServiceTemplate, sourceNodeType)) {
 339                 isValidSourceForConnectedOut = true;
 340             }
 341             for (Object obj : outputDependsOnNodeRequirementMap.get(sourceNodeTemplateId)) {
 342                 RequirementAssignment req = new ObjectMapper().convertValue(obj, RequirementAssignment
 343                         .class);
 344                 String targetNodeTemplateId = req.getNode();
 345                 Optional<NodeTemplate> targetNodeTemplate = analyzerService.getNodeTemplateById
 346                         (outputServiceTemplate, targetNodeTemplateId);
 347                 String targetNodeType = targetNodeTemplate.get().getType();
 348
 349                 if (isValidSourceForConnectedOut) {
 350                     //Should be present if source node is compute or port
 351                     if (computeNodeTemplateId.equals(sourceNodeTemplateId)) {
 352                         Assert.assertTrue(nodesConnectedOut.containsKey(targetNodeTemplateId));
 353                     }
 354                 }
 355
 356                 if (sourceNodeType.startsWith(ToscaNodeType.NOVA_SERVER)
 357                         && (targetNodeType.startsWith(ToscaNodeType.NOVA_SERVER)
 358                         || targetNodeType.startsWith(ToscaNodeType.NEUTRON_PORT)
 359                         || targetNodeType.startsWith(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE))) {
 360                     //Ignore Compute->Port, Compute->Compute, Compute->Volume relationship
 361                     Assert.assertFalse(nodesConnectedOut.containsKey(targetNodeTemplateId));
 362                 }
 363
 364                 if (sourceNodeType.startsWith(ToscaNodeType.NEUTRON_PORT)
 365                         && (targetNodeType.startsWith(ToscaNodeType.NOVA_SERVER)
 366                         || targetNodeType.startsWith(ToscaNodeType.NEUTRON_PORT)
 367                         || targetNodeType.startsWith(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE))) {
 368                     //Ignore Port->Port, Port->Compute, Port->Volume relationship
 369                     Assert.assertFalse(nodesConnectedOut.containsKey(targetNodeTemplateId));
 370                 }
 371             }
 372         }
 373
 374     }
 375
 376   private static Map<String,Map<String,List<String>>> getPortsInConsolidationData(ServiceTemplate
 377                                                                                       output){
 378     Map<String,Map<String,List<String>>> portMap = new LinkedHashMap<>();
 379     Map<String, NodeTemplate> nodeTempMap = output.getTopology_template().getNode_templates();
 380     for(String nodeName : nodeTempMap.keySet()){
 381       NodeTemplate node = nodeTempMap.get(nodeName);
 382       if(ToscaNodeType.NEUTRON_PORT.equals(node.getType()) || ToscaNodeType
 383           .CONTRAILV2_VIRTUAL_MACHINE_INTERFACE.equals(node.getType())){
 384         List<Map<String, RequirementAssignment>>  reqAssignList = node.getRequirements();
 385         if(reqAssignList != null) {
 386           for (Map<String, RequirementAssignment> reqAssignMap : reqAssignList) {
 387             //RequirementAssignment req = reqAssignMap.get("binding");
 388             RequirementAssignment req = new ObjectMapper().convertValue(reqAssignMap.get("binding"),
 389                 RequirementAssignment.class);
 390
 391             if (req != null) {
 392               String portNode = req.getNode();
 393               if (!portMap.containsKey(portNode)) {
 394                 portMap.put(portNode, new LinkedHashMap<>());
 395               }
 396               Map<String, List<String>> portTypMaps = portMap.get(portNode);
 397               String id = ConsolidationDataUtil.getPortType(nodeName, "a");
 398               if (!portTypMaps.containsKey(id)) {
 399                 portTypMaps.put(id, new ArrayList<>());
 400               }
 401               List<String> portIds = portTypMaps.get(id);
 402               portIds.add(nodeName);
 403             }
 404           }
 405         }
 406       }
 407     }
 408     return portMap;
 409   }
 410
 411   public static void validateGroupsInConsolidationData(String computeNodeTemplateId,
 412                                                        ComputeTemplateConsolidationData
 413                                                            computeTemplateConsolidationData,
 414                                                        ServiceTemplate expectedServiceTemplate) {
 415     Assert.assertNotNull(computeTemplateConsolidationData);
 416     List<String> groupIds = computeTemplateConsolidationData.getGroupIds();
 417     if (groupIds != null) {
 418       for (String groupId : groupIds) {
 419         isComputeGroupMember(expectedServiceTemplate, computeNodeTemplateId, groupId);
 420       }
 421     }
 422   }
 423
 424   private static void isComputeGroupMember(ServiceTemplate expectedServiceTemplate, String
 425       computeNodeTemplateId, String groupId) {
 426     //Check if the collected group id is in the member list of the groups
 427     GroupDefinition group = expectedServiceTemplate.getTopology_template().getGroups().get(groupId);
 428     List<String> groupMembers = group.getMembers();
 429     Assert.assertNotNull(groupMembers);
 430     Assert.assertTrue(groupMembers.contains(computeNodeTemplateId));
 431   }
 432
 433   public static void validateNestedConsolidationDataNodeTemplateIds(ConsolidationData consolidationData,
 434                                                                     Map<String, ServiceTemplate>
 435                                                                       expectedServiceTemplateModels ){
 436     Map<String,List<String>> consolidatedMap = getSubstituteNodeTemplateIds(consolidationData);
 437     Map<String,List<String>> expectedMap = getSubstituteMapping(expectedServiceTemplateModels);
 438     for(String consolidatedKey : consolidatedMap.keySet()){
 439       List<String> consolidatedList = consolidatedMap.get(consolidatedKey);
 440       List<String> expectedList = expectedMap.get(consolidatedKey);
 441       if(expectedList == null ){
 442         Assert.fail();
 443       } if(!CollectionUtils.isEqualCollection(consolidatedList,expectedList)){
 444         Assert.fail();
 445       }
 446     }
 447   }
 448
 449   private static Map<String,List<String>> getSubstituteNodeTemplateIds(ConsolidationData
 450                                                                    consolidationData) {
 451     Map<String,List<String>> nestedNodeTemplateIdMap = new HashMap<>();
 452     NestedConsolidationData nestedConsolidationData =
 453         consolidationData.getNestedConsolidationData();
 454     Set<String> serviceTemplateFileNames =
 455         nestedConsolidationData.getAllServiceTemplateFileNames();
 456     for (String fileName : serviceTemplateFileNames) {
 457       FileNestedConsolidationData fileNestedConsolidationData =
 458           nestedConsolidationData.getFileNestedConsolidationData(fileName);
 459       if (Objects.isNull(fileNestedConsolidationData)) {
 460         continue;
 461       }
 462       Set<String> nestedNodeTemplateIds =
 463           fileNestedConsolidationData.getAllNestedNodeTemplateIds();
 464       if (nestedNodeTemplateIds != null) {
 465         List<String> fileNestedNodeTemplateIds = new ArrayList<>(nestedNodeTemplateIds);
 466         nestedNodeTemplateIdMap.put(fileName, fileNestedNodeTemplateIds);
 467       }
 468     }
 469     return nestedNodeTemplateIdMap;
 470   }
 471
 472     private static Map<String, List<String>> getSubstituteMapping(Map<String, ServiceTemplate>
 473                                                                           expectedServiceTemplateModels) {
 474         Map<String, List<String>> map = new LinkedHashMap<>();
 475         for (String key : expectedServiceTemplateModels.keySet()) {
 476             ServiceTemplate serviceTemplate = expectedServiceTemplateModels.get(key);
 477             if (serviceTemplate.getTopology_template() != null && serviceTemplate
 478                     .getTopology_template().getNode_templates() != null) {
 479                 for (String key1 : serviceTemplate.getTopology_template().getNode_templates().keySet()) {
 480                     NodeTemplate nodeTemplate = serviceTemplate.getTopology_template().getNode_templates()
 481                             .get(key1);
 482                     if (nodeTemplate.getType().contains(ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat.")) {
 483                         List<String> subNodeTempIdList = map.computeIfAbsent(key, k -> new ArrayList<>());
 484                         subNodeTempIdList.add(key1);
 485                     }
 486                 }
 487             }
 488         }
 489         return map;
 490     }
 491
 492     public static void validateComputeConnectivityIn(ComputeTemplateConsolidationData
 493                                                              computeTemplateConsolidationData,
 494                                                      ServiceTemplate expectedServiceTemplate) {
 495         Multimap<String, RequirementAssignmentData> nodesConnectedIn =
 496                 computeTemplateConsolidationData.getNodesConnectedIn();
 497         if (nodesConnectedIn == null) {
 498             return;
 499         }
 500
 501         validateConnectivity(null, nodesConnectedIn, expectedServiceTemplate);
 502     }
 503
 504     public static void validateComputeConnectivityOut(String computeNodeTemplateId,
 505                                                       ComputeTemplateConsolidationData computeTemplateConsolidationData,
 506                                                       ServiceTemplate expectedServiceTemplate) {
 507         Multimap<String, RequirementAssignmentData> nodesConnectedOut =
 508                 computeTemplateConsolidationData.getNodesConnectedOut();
 509         if (nodesConnectedOut == null) {
 510             return;
 511         }
 512
 513         validateConnectivity(computeNodeTemplateId, nodesConnectedOut, expectedServiceTemplate);
 514     }
 515
 516     public static void validatePortConnectivityIn(PortTemplateConsolidationData portTemplateConsolidationData,
 517                                                   ServiceTemplate expectedServiceTemplate) {
 518         Multimap<String, RequirementAssignmentData> nodesConnectedIn =
 519                 portTemplateConsolidationData.getNodesConnectedIn();
 520         if (nodesConnectedIn == null) {
 521             return;
 522         }
 523
 524         validateConnectivity(null, nodesConnectedIn, expectedServiceTemplate);
 525     }
 526
 527     public static void validatePortConnectivityOut(String portNodeTemplateId,
 528                                                    PortTemplateConsolidationData portTemplateConsolidationData,
 529                                                    ServiceTemplate expectedServiceTemplate) {
 530         Multimap<String, RequirementAssignmentData> nodesConnectedOut =
 531                 portTemplateConsolidationData.getNodesConnectedOut();
 532         if (nodesConnectedOut == null) {
 533             return;
 534         }
 535
 536         validateConnectivity(portNodeTemplateId, nodesConnectedOut, expectedServiceTemplate);
 537     }
 538
 539     private static void validateConnectivity(String nodeTemplateId,
 540                                              Multimap<String, RequirementAssignmentData> nodesConnected,
 541                                              ServiceTemplate expectedServiceTemplate) {
 542         boolean found = false;
 543         for (String nodeIdConnTo : nodesConnected.keySet()) {
 544             Collection<RequirementAssignmentData> connectToList = nodesConnected.get(nodeIdConnTo);
 545             List<Map<String, RequirementAssignment>> requirementsList = expectedServiceTemplate
 546                     .getTopology_template().getNode_templates()
 547                     .get(nodeTemplateId != null ? nodeTemplateId : nodeIdConnTo).getRequirements();
 548
 549             for (RequirementAssignmentData requirementAssignmentData : connectToList) {
 550                 for (Map<String, RequirementAssignment> requirementAssignmentMap : requirementsList) {
 551                     RequirementAssignment requirementAssignment =
 552                             new ObjectMapper().convertValue(requirementAssignmentMap.values().iterator().next(),
 553                                     RequirementAssignment.class);
 554                     if (requirementAssignment.getNode()
 555                             .equals(requirementAssignmentData.getRequirementAssignment().getNode())) {
 556                         Assert.assertEquals(requirementAssignment.getCapability(),
 557                                 requirementAssignmentData.getRequirementAssignment().getCapability());
 558                         Assert.assertEquals(requirementAssignment.getNode(),
 559                                 requirementAssignmentData.getRequirementAssignment().getNode());
 560                         Assert.assertEquals(requirementAssignment.getRelationship(),
 561                                 requirementAssignmentData.getRequirementAssignment()
 562                                         .getRelationship());
 563                         found = true;
 564                     }
 565                 }
 566                 if (!found) {
 567                     Assert.fail();
 568                 }
 569                 found = false;
 570             }
 571         }
 572     }
 573
 574   public static void validateGetAttr(TranslationContext translationContext, String testName){
 575     ConsolidationData consolidationData = translationContext.getConsolidationData();
 576     Assert.assertNotNull(consolidationData);
 577     if(TestConstants.TEST_GET_ATTR_FOR_MORE_THAN_ONE_ATTR_IN_ATTR_LIST.equals(testName)){
 578       PortTemplateConsolidationData portTemplateConsolidationData = consolidationData
 579           .getPortConsolidationData().getFilePortConsolidationData("ep-jsa_netServiceTemplate.yaml")
 580           .getPortTemplateConsolidationData("VMI1");
 581       Assert.assertNotNull(portTemplateConsolidationData);
 582       Assert.assertEquals(2, portTemplateConsolidationData.getNodesGetAttrIn().size());
 583       List<GetAttrFuncData> attrFuncDataList = portTemplateConsolidationData.getNodesGetAttrIn()
 584           .get("FSB1");
 585       Assert.assertEquals(1,attrFuncDataList.size());
 586       Assert.assertEquals("name",attrFuncDataList.get(0).getFieldName());
 587       Assert.assertEquals("name",attrFuncDataList.get(0).getAttributeName());
 588
 589       attrFuncDataList = portTemplateConsolidationData.getNodesGetAttrIn()
 590           .get("FSB2");
 591       Assert.assertEquals(1,attrFuncDataList.size());
 592       Assert.assertEquals("name",attrFuncDataList.get(0).getFieldName());
 593       Assert.assertEquals("virtual_machine_interface_allowed_address_pairs",attrFuncDataList.get(0).getAttributeName());
 594
 595       ComputeTemplateConsolidationData computeTemplateConsolidationDataFSB2 = consolidationData
 596           .getComputeConsolidationData()
 597           .getFileComputeConsolidationData("ep-jsa_netServiceTemplate.yaml")
 598           .getTypeComputeConsolidationData("org.openecomp.resource.vfc.nodes.heat.FSB2")
 599           .getComputeTemplateConsolidationData("FSB2");
 600       Assert.assertEquals(1,computeTemplateConsolidationDataFSB2.getNodesGetAttrOut().size());
 601       List<GetAttrFuncData> attrFuncDataOutList = computeTemplateConsolidationDataFSB2
 602           .getNodesGetAttrOut().get("VMI1");
 603       Assert.assertEquals(1,attrFuncDataOutList.size());
 604       Assert.assertEquals("name",attrFuncDataOutList.get(0).getFieldName());
 605       Assert.assertEquals("virtual_machine_interface_allowed_address_pairs",attrFuncDataOutList
 606           .get(0).getAttributeName());
 607       ComputeTemplateConsolidationData computeTemplateConsolidationDataFSB1 = consolidationData
 608           .getComputeConsolidationData()
 609           .getFileComputeConsolidationData("ep-jsa_netServiceTemplate.yaml")
 610           .getTypeComputeConsolidationData("org.openecomp.resource.vfc.nodes.heat.FSB1")
 611           .getComputeTemplateConsolidationData("FSB1");
 612       Assert.assertEquals(1,computeTemplateConsolidationDataFSB1.getNodesGetAttrOut().size());
 613       List<GetAttrFuncData> attrFuncDataOutList2 = computeTemplateConsolidationDataFSB1
 614           .getNodesGetAttrOut().get("VMI1");
 615       Assert.assertEquals(1,attrFuncDataOutList2.size());
 616       Assert.assertEquals("name",attrFuncDataOutList2.get(0).getFieldName());
 617       Assert.assertEquals("name",attrFuncDataOutList2
 618           .get(0).getAttributeName());
 619     } else if(TestConstants.TEST_IGNORE_GET_ATTR_FROM_OUTPUT.equals(testName)){
 620       if(!consolidationData.getPortConsolidationData().getAllServiceTemplateFileNames().isEmpty()){
 621         Iterator<String> itr = consolidationData.getPortConsolidationData()
 622             .getFilePortConsolidationData("MainServiceTemplate.yaml").getAllPortNodeTemplateIds()
 623             .iterator();
 624         while(itr.hasNext()){
 625           String key = itr.next();
 626           PortTemplateConsolidationData portTemplateConsolidationData = consolidationData
 627               .getPortConsolidationData()
 628               .getFilePortConsolidationData("MainServiceTemplate.yaml")
 629               .getPortTemplateConsolidationData(key);
 630           Assert.assertNull(portTemplateConsolidationData.getOutputParametersGetAttrIn());
 631         }
 632       }
 633     } else if(TestConstants.TEST_GET_ATTR_FOR_NOT_SUPPORTED_ATTR_IN_ATTR_LIST.equals(testName)){
 634       Assert.assertNull(consolidationData.getPortConsolidationData()
 635           .getFilePortConsolidationData("MainServiceTemplate.yaml")
 636           .getPortTemplateConsolidationData("FSB1_Internal2").getNodesGetAttrIn());
 637     } else if(TestConstants.TEST_GET_ATTR_FOR_ONLY_RESOURCE_NAME.equals(testName)){
 638       PortTemplateConsolidationData portTemplateConsolidationData = consolidationData
 639           .getPortConsolidationData().getFilePortConsolidationData("MainServiceTemplate.yaml")
 640           .getPortTemplateConsolidationData("VMI1");
 641       Assert.assertNotNull(portTemplateConsolidationData);
 642       Assert.assertEquals("name",portTemplateConsolidationData.getNodesGetAttrIn().get("FSB1").
 643           get(0).getFieldName());
 644       Assert.assertEquals("tenant_id",portTemplateConsolidationData.getNodesGetAttrIn().get("FSB1").
 645           get(0).getAttributeName());
 646     } else if(TestConstants.TEST_GET_ATTR_FOR_NONE_TO_PORT_OR_COMPUTE.equals(testName)){
 647       ComputeTemplateConsolidationData computeTemplateConsolidationData = consolidationData
 648           .getComputeConsolidationData()
 649           .getFileComputeConsolidationData("MainServiceTemplate.yaml")
 650           .getTypeComputeConsolidationData("org.openecomp.resource.vfc.nodes.heat.compute")
 651           .getComputeTemplateConsolidationData("server_compute_get_attr_test");
 652       Assert.assertEquals("user_data_format",computeTemplateConsolidationData
 653           .getNodesGetAttrOut().get("server_pcm_001").get(0).getFieldName());
 654       Assert.assertEquals("oam_net_gw",computeTemplateConsolidationData
 655           .getNodesGetAttrOut().get("server_pcm_001").get(0).getAttributeName());
 656     } else if(TestConstants.TEST_OUTPUT_GET_ATTR.equals(testName)){
 657       ComputeTemplateConsolidationData computeTemplateConsolidationData1 = consolidationData
 658           .getComputeConsolidationData()
 659           .getFileComputeConsolidationData("firstnet_fgi_frwlServiceTemplate.yaml")
 660           .getTypeComputeConsolidationData("org.openecomp.resource.vfc.nodes.heat.cgi_fw")
 661           .getComputeTemplateConsolidationData("CGI_FW_SERVER_1");
 662       Assert.assertEquals("cgi_fw_01_left_mac_1",computeTemplateConsolidationData1
 663           .getOutputParametersGetAttrIn()
 664           .get(0).getFieldName());
 665       Assert.assertEquals("addresses",computeTemplateConsolidationData1.getOutputParametersGetAttrIn()
 666           .get(0).getAttributeName());
 667       ComputeTemplateConsolidationData computeTemplateConsolidationData2 = consolidationData
 668           .getComputeConsolidationData()
 669           .getFileComputeConsolidationData("firstnet_fgi_frwlServiceTemplate.yaml")
 670           .getTypeComputeConsolidationData("org.openecomp.resource.vfc.nodes.heat.cgi_fw")
 671           .getComputeTemplateConsolidationData("CGI_FW_SERVER_2");
 672       Assert.assertEquals(1,computeTemplateConsolidationData2
 673           .getNodesGetAttrIn().get("CGI_FW_SERVER_2").size());
 674       Assert.assertEquals("availability_zone",computeTemplateConsolidationData2
 675           .getNodesGetAttrIn().get("CGI_FW_SERVER_2").get(0).getFieldName());
 676       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 677           .getNodesGetAttrIn().get("CGI_FW_SERVER_2").get(0).getAttributeName());
 678       Assert.assertEquals(1,computeTemplateConsolidationData2
 679           .getNodesGetAttrOut().get("CGI_FW_SERVER_2").size());
 680       Assert.assertEquals("availability_zone",computeTemplateConsolidationData2
 681           .getNodesGetAttrOut().get("CGI_FW_SERVER_2").get(0).getFieldName());
 682       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 683           .getNodesGetAttrOut().get("CGI_FW_SERVER_2").get(0).getAttributeName());
 684       Assert.assertEquals("cgi_fw_01_left_mac_2",computeTemplateConsolidationData2
 685           .getOutputParametersGetAttrIn().get(0).getFieldName());
 686       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 687           .getOutputParametersGetAttrIn().get(0).getAttributeName());
 688       Assert.assertEquals("cgi_fw_01_left_mac_3",computeTemplateConsolidationData2
 689           .getOutputParametersGetAttrIn().get(1).getFieldName());
 690       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 691           .getOutputParametersGetAttrIn().get(1).getAttributeName());
 692       Assert.assertEquals("cgi_fw_01_left_mac_4",computeTemplateConsolidationData2
 693           .getOutputParametersGetAttrIn().get(2).getFieldName());
 694       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 695           .getOutputParametersGetAttrIn().get(2).getAttributeName());
 696       Assert.assertEquals("cgi_fw_01_left_mac_5",computeTemplateConsolidationData2
 697           .getOutputParametersGetAttrIn().get(3).getFieldName());
 698       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 699           .getOutputParametersGetAttrIn().get(3).getAttributeName());
 700       Assert.assertEquals("cgi_fw_01_left_mac_5",computeTemplateConsolidationData2
 701           .getOutputParametersGetAttrIn().get(4).getFieldName());
 702       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 703           .getOutputParametersGetAttrIn().get(4).getAttributeName());
 704       Assert.assertEquals("cgi_fw_01_left_mac_6",computeTemplateConsolidationData2
 705           .getOutputParametersGetAttrIn().get(5).getFieldName());
 706       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 707           .getOutputParametersGetAttrIn().get(5).getAttributeName());
 708       Assert.assertEquals("cgi_fw_01_left_mac_9",computeTemplateConsolidationData2
 709           .getOutputParametersGetAttrIn().get(6).getFieldName());
 710       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 711           .getOutputParametersGetAttrIn().get(6).getAttributeName());
 712       Assert.assertEquals("cgi_fw_01_left_mac_10",computeTemplateConsolidationData2
 713           .getOutputParametersGetAttrIn().get(7).getFieldName());
 714       Assert.assertEquals("addresses",computeTemplateConsolidationData2
 715           .getOutputParametersGetAttrIn().get(7).getAttributeName());
 716       PortTemplateConsolidationData portTemplateConsolidationData = consolidationData
 717           .getPortConsolidationData().getFilePortConsolidationData("firstnet_fgi_frwlServiceTemplate.yaml")
 718           .getPortTemplateConsolidationData("contrail_vmi_subinterface");
 719       Assert.assertEquals("cgi_fw_01_left_mac_7",portTemplateConsolidationData
 720           .getOutputParametersGetAttrIn().get(0).getFieldName());
 721       Assert.assertEquals("virtual_machine_interface_properties",portTemplateConsolidationData
 722           .getOutputParametersGetAttrIn().get(0).getAttributeName());
 723       Assert.assertEquals("cgi_fw_01_left_mac_8",portTemplateConsolidationData
 724           .getOutputParametersGetAttrIn().get(1).getFieldName());
 725       Assert.assertEquals("virtual_machine_interface_allowed_address_pairs",
 726           portTemplateConsolidationData.getOutputParametersGetAttrIn()
 727               .get(1).getAttributeName());
 728       Assert.assertEquals("cgi_fw_01_left_mac_10",portTemplateConsolidationData
 729           .getOutputParametersGetAttrIn().get(2).getFieldName());
 730       Assert.assertEquals("virtual_machine_interface_allowed_address_pairs",
 731           portTemplateConsolidationData.getOutputParametersGetAttrIn()
 732               .get(2).getAttributeName());
 733     }
 734   }
 735
 736     public static void validateNestedConsolidationData(TranslationContext context,
 737                                                        String testName) {
 738         ConsolidationData consolidationData = context.getConsolidationData();
 739         if (testName.equals(TEST_SINGLE_NESTED_RESOURCE)) {
 740             String nestedNodeTemplateId = "server_pcm_001";
 741             NestedTemplateConsolidationData nestedTemplateConsolidationData =
 742                     consolidationData.getNestedConsolidationData()
 743                             .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 744                             .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 745             //Validate basic null attributes
 746             validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 747             //Validate nodeTemplateId
 748             Assert.assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(), nestedNodeTemplateId);
 749             //Validate nodes connected in (will only be populated for dependsOn relationships)
 750             List<String> dependentNodes = new LinkedList<>();
 751             dependentNodes.add("packet_mirror_network");
 752
 753             //Validate get attribute in
 754             Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
 755                     nestedTemplateConsolidationData.getNodesGetAttrIn();
 756             String getAttrNodeTemplateId = "server_compute_get_attr_test";
 757             List<GetAttrFuncData> getAttrFuncData = nodesGetAttrIn.get(getAttrNodeTemplateId);
 758             Assert.assertNotNull(getAttrFuncData);
 759             Assert.assertEquals(getAttrFuncData.size(), 2);
 760             Assert.assertEquals(getAttrFuncData.get(0).getFieldName(), "metadata");
 761             Assert.assertEquals(getAttrFuncData.get(0).getAttributeName(), "server_pcm_id");
 762             Assert.assertEquals(getAttrFuncData.get(1).getFieldName(), "user_data_format");
 763             Assert.assertEquals(getAttrFuncData.get(1).getAttributeName(), "oam_net_gw");
 764
 765             //Validate output parameter get attribute in
 766             List<GetAttrFuncData> outputParametersGetAttrIn =
 767                     nestedTemplateConsolidationData.getOutputParametersGetAttrIn();
 768             Assert.assertNotNull(outputParametersGetAttrIn);
 769             Assert.assertEquals(outputParametersGetAttrIn.size(), 1);
 770             Assert.assertEquals(outputParametersGetAttrIn.get(0).getFieldName(), "output_attr_1");
 771             Assert.assertEquals(outputParametersGetAttrIn.get(0).getAttributeName(), "pcm_vol");
 772
 773         } else if (testName.equals(TEST_MULTIPLE_NESTED_RESOURCE)) {
 774             List<String> nestedNodeTemplateIds = new ArrayList<>();
 775             nestedNodeTemplateIds.add("server_pcm_001");
 776             nestedNodeTemplateIds.add("server_pcm_002");
 777             nestedNodeTemplateIds.add("server_pcm_003");
 778
 779             for (String nestedNodeTemplateId : nestedNodeTemplateIds) {
 780                 NestedTemplateConsolidationData nestedTemplateConsolidationData =
 781                         consolidationData.getNestedConsolidationData()
 782                                 .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 783                                 .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 784                 //Validate basic null attributes
 785                 validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 786                 //Validate nodeTemplateId
 787                 Assert.assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(),
 788                         nestedNodeTemplateId);
 789                 if (!nestedNodeTemplateId.equals("server_pcm_001")) {
 790                     Assert.assertNull(nestedTemplateConsolidationData.getNodesConnectedIn());
 791                 }
 792             }
 793             String nestedNodeTemplateId = "server_pcm_001";
 794
 795             //Validate get attribute in
 796             NestedTemplateConsolidationData nestedTemplateConsolidationData =
 797                     consolidationData.getNestedConsolidationData()
 798                             .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 799                             .getNestedTemplateConsolidationData("server_pcm_002");
 800             Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
 801                     nestedTemplateConsolidationData.getNodesGetAttrIn();
 802             String getAttrNodeTemplateId = "server_pcm_001";
 803             List<GetAttrFuncData> getAttrFuncData = nodesGetAttrIn.get(getAttrNodeTemplateId);
 804             Assert.assertNotNull(getAttrFuncData);
 805             Assert.assertEquals(getAttrFuncData.size(), 1);
 806             Assert.assertEquals(getAttrFuncData.get(0).getFieldName(), "user_data_format");
 807             Assert.assertEquals(getAttrFuncData.get(0).getAttributeName(), "pcm_vol");
 808             //Validate output parameter get attribute in
 809             List<GetAttrFuncData> outputParametersGetAttrIn =
 810                     nestedTemplateConsolidationData.getOutputParametersGetAttrIn();
 811             Assert.assertNotNull(outputParametersGetAttrIn);
 812             Assert.assertEquals(outputParametersGetAttrIn.size(), 1);
 813             Assert.assertEquals(outputParametersGetAttrIn.get(0).getFieldName(), "output_attr_2");
 814             Assert.assertEquals(outputParametersGetAttrIn.get(0).getAttributeName(), "oam_net_ip");
 815
 816
 817             nestedTemplateConsolidationData = consolidationData.getNestedConsolidationData()
 818                     .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 819                     .getNestedTemplateConsolidationData("server_pcm_001");
 820             nodesGetAttrIn = nestedTemplateConsolidationData.getNodesGetAttrIn();
 821             getAttrNodeTemplateId = "server_pcm_002";
 822             getAttrFuncData = nodesGetAttrIn.get(getAttrNodeTemplateId);
 823             Assert.assertNotNull(getAttrFuncData);
 824             Assert.assertEquals(getAttrFuncData.size(), 1);
 825             Assert.assertEquals(getAttrFuncData.get(0).getFieldName(), "metadata");
 826             Assert.assertEquals(getAttrFuncData.get(0).getAttributeName(), "server_pcm_id");
 827             //Validate output parameter get attribute in
 828             outputParametersGetAttrIn = nestedTemplateConsolidationData.getOutputParametersGetAttrIn();
 829             Assert.assertNotNull(outputParametersGetAttrIn);
 830             Assert.assertEquals(outputParametersGetAttrIn.size(), 1);
 831             Assert.assertEquals(outputParametersGetAttrIn.get(0).getFieldName(), "output_attr_1");
 832             Assert.assertEquals(outputParametersGetAttrIn.get(0).getAttributeName(), "pcm_vol");
 833
 834             nestedTemplateConsolidationData = consolidationData.getNestedConsolidationData()
 835                     .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 836                     .getNestedTemplateConsolidationData("server_pcm_003");
 837             Assert.assertNull(nestedTemplateConsolidationData.getNodesGetAttrIn());
 838             Assert.assertNull(nestedTemplateConsolidationData.getOutputParametersGetAttrIn());
 839
 840         } else if (testName.equals(TEST_MULTIPLE_MULTI_LEVEL_NESTED_RESOURCE)) {
 841             String nestedNodeTemplateId = "test_nested";
 842             NestedTemplateConsolidationData nestedTemplateConsolidationData =
 843                     consolidationData.getNestedConsolidationData()
 844                             .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 845                             .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 846             //Validate basic null attributes
 847             validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 848             //Validate nodeTemplateId
 849             Assert.assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(),
 850                     nestedNodeTemplateId);
 851             //Validate nodes connected in (will only be populated for dependsOn relationships)
 852             Multimap<String, RequirementAssignmentData> nodesConnectedIn =
 853                     nestedTemplateConsolidationData.getNodesConnectedIn();
 854             List<String> dependentNodes = new LinkedList<>();
 855             dependentNodes.add("packet_mirror_network");
 856             //Validate output parameter get attribute in
 857             List<GetAttrFuncData> getAttrFuncData =
 858                     nestedTemplateConsolidationData.getNodesGetAttrIn().get("packet_mirror_network");
 859             Assert.assertNotNull(getAttrFuncData);
 860             Assert.assertEquals(getAttrFuncData.size(), 1);
 861             Assert.assertEquals(getAttrFuncData.get(0).getFieldName(), "shared");
 862             Assert.assertEquals(getAttrFuncData.get(0).getAttributeName(), "output_attr_1");
 863             Assert.assertNull(nestedTemplateConsolidationData.getOutputParametersGetAttrIn());
 864
 865             nestedNodeTemplateId = "test_nested2";
 866             nestedTemplateConsolidationData = consolidationData.getNestedConsolidationData()
 867                     .getFileNestedConsolidationData("nestedServiceTemplate.yaml")
 868                     .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 869             //Validate basic null attributes
 870             validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 871             //Validate nodeTemplateId
 872             Assert.assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(),
 873                     nestedNodeTemplateId);
 874             Assert.assertNull(nestedTemplateConsolidationData.getNodesConnectedIn());
 875             //Validate output parameter get attribute in
 876             getAttrFuncData = nestedTemplateConsolidationData.getNodesGetAttrIn().get("server_cmaui_1");
 877             Assert.assertNotNull(getAttrFuncData);
 878             Assert.assertEquals(getAttrFuncData.size(), 1);
 879             Assert.assertEquals(getAttrFuncData.get(0).getFieldName(), "metadata");
 880             Assert.assertEquals(getAttrFuncData.get(0).getAttributeName(), "availability_zone_0");
 881
 882             List<GetAttrFuncData> outputParametersGetAttrIn1 =
 883                     nestedTemplateConsolidationData.getOutputParametersGetAttrIn();
 884             Assert.assertNotNull(outputParametersGetAttrIn1);
 885             Assert.assertEquals(outputParametersGetAttrIn1.size(), 1);
 886             Assert.assertEquals(outputParametersGetAttrIn1.get(0).getFieldName(), "output_attr_1");
 887             Assert.assertEquals(outputParametersGetAttrIn1.get(0).getAttributeName(), "availability_zone_0");
 888         }
 889     }
 890
 891     private static void validateBasicNestedConsolidationData(NestedTemplateConsolidationData
 892                                                                      nestedTemplateConsolidationData) {
 893         Assert.assertNull(nestedTemplateConsolidationData.getGroupIds());
 894         Assert.assertNull(nestedTemplateConsolidationData.getNodesConnectedOut());
 895     }
 896
 897     public static void validateNestedNodesConnectedInSecurityRuleToPort(String testName, TranslationContext context) {
 898         ConsolidationData consolidationData = context.getConsolidationData();
 899         if (testName.equals(TEST_SECURITY_RULE_PORT_NESTED_CONNECTION) ||
 900                 testName.equals(TestConstants.TEST_SECURITY_RULE_PORT_NESTED_SHARED_PORT)) {
 901             String nestedNodeTemplateId = "test_nested";
 902             NestedTemplateConsolidationData nestedTemplateConsolidationData =
 903                     consolidationData.getNestedConsolidationData()
 904                             .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 905                             .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 906             //Validate basic null attributes
 907             validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 908             //Validate nodeTemplateId
 909             Assert
 910                     .assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(), nestedNodeTemplateId);
 911             String securityRuleNodeTemplateId = "jsa_security_group1";
 912             validateNestedNodesConnectedInSecurityRuleToPort(HeatToToscaUtil
 913                             .getServiceTemplateFromContext(MAIN_SERVICE_TEMPLATE, context).get(),
 914                     nestedNodeTemplateId, securityRuleNodeTemplateId,
 915                     nestedTemplateConsolidationData);
 916             securityRuleNodeTemplateId = "jsa_security_group2";
 917             validateNestedNodesConnectedInSecurityRuleToPort(HeatToToscaUtil
 918                             .getServiceTemplateFromContext(MAIN_SERVICE_TEMPLATE, context).get(),
 919                     nestedNodeTemplateId, securityRuleNodeTemplateId,
 920                     nestedTemplateConsolidationData);
 921             if (testName.equals(TestConstants.TEST_SECURITY_RULE_PORT_NESTED_SHARED_PORT)) {
 922                 nestedNodeTemplateId = "test_nestedArrayParam";
 923                 Assert.assertEquals(nestedNodeTemplateId, consolidationData.getNestedConsolidationData()
 924                         .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 925                         .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodeTemplateId());
 926                 Assert.assertNull(consolidationData.getNestedConsolidationData()
 927                         .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 928                         .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodesConnectedIn());
 929             }
 930         } else if (testName.equals(TEST_SECURITY_RULE_PORT_MULTI_LEVEL_NESTED_CONNECTION) ||
 931                 testName.equals(TEST_SECURITY_RULE_PORT_MULTI_LEVEL_NESTED_SHARED_PORT)) {
 932             String nestedNodeTemplateId = "test_nested2Level";
 933             Assert.assertEquals(nestedNodeTemplateId, consolidationData.getNestedConsolidationData()
 934                     .getFileNestedConsolidationData("nested1ServiceTemplate.yaml")
 935                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodeTemplateId());
 936             Assert.assertNull(consolidationData.getNestedConsolidationData()
 937                     .getFileNestedConsolidationData("nested1ServiceTemplate.yaml")
 938                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodesConnectedIn());
 939             nestedNodeTemplateId = "test_nested3Level";
 940             Assert.assertEquals(nestedNodeTemplateId, consolidationData.getNestedConsolidationData()
 941                     .getFileNestedConsolidationData("nested2ServiceTemplate.yaml")
 942                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodeTemplateId());
 943             Assert.assertNull(consolidationData.getNestedConsolidationData()
 944                     .getFileNestedConsolidationData("nested2ServiceTemplate.yaml")
 945                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodesConnectedIn());
 946             nestedNodeTemplateId = "test_nested4Level";
 947             Assert.assertEquals(nestedNodeTemplateId, consolidationData.getNestedConsolidationData()
 948                     .getFileNestedConsolidationData("nested3ServiceTemplate.yaml")
 949                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodeTemplateId());
 950             Assert.assertNull(consolidationData.getNestedConsolidationData()
 951                     .getFileNestedConsolidationData("nested3ServiceTemplate.yaml")
 952                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodesConnectedIn());
 953
 954             //Validate main service template
 955
 956             nestedNodeTemplateId = "test_nested1Level";
 957             NestedTemplateConsolidationData nestedTemplateConsolidationData =
 958                     consolidationData.getNestedConsolidationData()
 959                             .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 960                             .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 961             //Validate basic null attributes
 962             validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 963             //Validate nodeTemplateId
 964             Assert
 965                     .assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(), nestedNodeTemplateId);
 966             String securityRuleNodeTemplateId = "jsa_security_group1";
 967             validateNestedNodesConnectedInSecurityRuleToPort(HeatToToscaUtil
 968                             .getServiceTemplateFromContext(MAIN_SERVICE_TEMPLATE, context).get(),
 969                     nestedNodeTemplateId, securityRuleNodeTemplateId,
 970                     nestedTemplateConsolidationData);
 971             securityRuleNodeTemplateId = "jsa_security_group2";
 972             validateNestedNodesConnectedInSecurityRuleToPort(HeatToToscaUtil
 973                             .getServiceTemplateFromContext(MAIN_SERVICE_TEMPLATE, context).get(),
 974                     nestedNodeTemplateId, securityRuleNodeTemplateId,
 975                     nestedTemplateConsolidationData);
 976
 977             nestedNodeTemplateId = "test_resourceGroup";
 978             nestedTemplateConsolidationData = consolidationData.getNestedConsolidationData()
 979                     .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
 980                     .getNestedTemplateConsolidationData(nestedNodeTemplateId);
 981             //Validate basic null attributes
 982             validateBasicNestedConsolidationData(nestedTemplateConsolidationData);
 983             //Validate nodeTemplateId
 984             Assert
 985                     .assertEquals(nestedTemplateConsolidationData.getNodeTemplateId(), nestedNodeTemplateId);
 986             securityRuleNodeTemplateId = "jsa_security_group2";
 987             validateNestedNodesConnectedInSecurityRuleToPort(HeatToToscaUtil
 988                             .getServiceTemplateFromContext(MAIN_SERVICE_TEMPLATE, context).get(),
 989                     nestedNodeTemplateId, securityRuleNodeTemplateId,
 990                     nestedTemplateConsolidationData);
 991             securityRuleNodeTemplateId = "jsa_security_group2";
 992             validateNestedNodesConnectedInSecurityRuleToPort(HeatToToscaUtil
 993                             .getServiceTemplateFromContext(MAIN_SERVICE_TEMPLATE, context).get(),
 994                     nestedNodeTemplateId, securityRuleNodeTemplateId,
 995                     nestedTemplateConsolidationData);
 996
 997             nestedNodeTemplateId = "test_nestedInvalidConnectionToNova";
 998             Assert.assertEquals(nestedNodeTemplateId, consolidationData.getNestedConsolidationData()
 999                     .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
1000                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodeTemplateId());
1001             Assert.assertNull(consolidationData.getNestedConsolidationData()
1002                     .getFileNestedConsolidationData(MAIN_SERVICE_TEMPLATE)
1003                     .getNestedTemplateConsolidationData(nestedNodeTemplateId).getNodesConnectedIn());
1004         }
1005     }
1006
1007     private static void validateNestedNodesConnectedInSecurityRuleToPort(ServiceTemplate serviceTemplate,
1008                                                                          String nestedNodeTemplateId,
1009                                                                          String securityRuleNodeTemplateId,
1010                                                                          NestedTemplateConsolidationData
1011                                                                                  nestedTemplateConsolidationData) {
1012         Multimap<String, RequirementAssignmentData> consolidationDataNodesConnectedIn =
1013                 nestedTemplateConsolidationData.getNodesConnectedIn();
1014         Assert.assertNotNull(consolidationDataNodesConnectedIn);
1015         NodeTemplate securityRuleNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1016                 securityRuleNodeTemplateId);
1017         List<Map<String, RequirementAssignment>> securityRuleNodeTemplateRequirements =
1018                 securityRuleNodeTemplate.getRequirements();
1019         for (Map<String, RequirementAssignment> req : securityRuleNodeTemplateRequirements) {
1020             String requirementId = req.keySet().toArray()[0].toString();
1021             if (requirementId.equals(ToscaConstants.PORT_REQUIREMENT_ID)) {
1022                 RequirementAssignment requirementAssignment = req.get(requirementId);
1023                 if (requirementAssignment.getNode().equals(nestedNodeTemplateId)) {
1024                     validateSecurityRulePortNestedConsolidationData(requirementAssignment,
1025                             securityRuleNodeTemplateId, consolidationDataNodesConnectedIn);
1026                 }
1027             }
1028         }
1029     }
1030
1031     private static void validateSecurityRulePortNestedConsolidationData(RequirementAssignment requirementAssignment,
1032                                                                         String securityRuleNodeTemplateId,
1033                                                                         Multimap<String, RequirementAssignmentData>
1034                                                                                 consolidationDataNodesConnectedIn) {
1035         Collection<RequirementAssignmentData> requirementAssignmentDataList =
1036                 consolidationDataNodesConnectedIn.get(securityRuleNodeTemplateId);
1037         Assert.assertNotNull(requirementAssignmentDataList);
1038         boolean result = false;
1039         for (RequirementAssignmentData data : requirementAssignmentDataList) {
1040             RequirementAssignment dataRequirementAssignment = data.getRequirementAssignment();
1041             result = DataModelUtil
1042                     .compareRequirementAssignment(requirementAssignment, dataRequirementAssignment);
1043             if (result) {
1044                 break;
1045             }
1046         }
1047         Assert.assertTrue(result);
1048     }
1049 }