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