openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/services/heattotosca/buildconsolidationdata/ConsolidationDataTestUtil.java

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