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