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

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