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