gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 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;
  18
  19 import org.apache.commons.collections4.CollectionUtils;
  20 import org.apache.commons.lang3.tuple.Pair;
  21 import org.codehaus.jackson.map.ObjectMapper;
  22 import org.junit.Assert;
  23 import org.openecomp.core.translator.api.HeatToToscaTranslator;
  24 import org.openecomp.core.utilities.file.FileUtils;
  25 import org.openecomp.sdc.common.utils.SdcCommon;
  26 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  27 import org.onap.sdc.tosca.datatypes.model.GroupDefinition;
  28 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  29 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  30 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  31 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
  32 import org.openecomp.sdc.tosca.services.DataModelUtil;
  33 import org.openecomp.sdc.tosca.services.ToscaConstants;
  34 import org.onap.sdc.tosca.services.ToscaExtensionYamlUtil;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
  41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  49 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
  50
  51 import java.io.File;
  52 import java.io.FileInputStream;
  53 import java.io.IOException;
  54 import java.io.InputStream;
  55 import java.net.URISyntaxException;
  56 import java.net.URL;
  57 import java.nio.file.NotDirectoryException;
  58 import java.util.ArrayList;
  59 import java.util.HashMap;
  60 import java.util.List;
  61 import java.util.ListIterator;
  62 import java.util.Map;
  63 import java.util.Objects;
  64 import java.util.Optional;
  65
  66 public class TestUtils {
  67   private static final String MANIFEST_NAME = SdcCommon.MANIFEST_NAME;
  68   private static String zipFilename = "VSP.zip";
  69   private static String validationFilename = "validationOutput.json";
  70
  71   private TestUtils() {
  72   }
  73
  74
  75   public static void addFilesToTranslator(HeatToToscaTranslator heatToToscaTranslator, String path)
  76       throws IOException {
  77     File manifestFile = new File(path);
  78     File[] files = manifestFile.listFiles();
  79     byte[] fileContent;
  80
  81     Assert.assertNotNull("manifest files is empty", files);
  82
  83     for (File file : files) {
  84
  85       try (FileInputStream fis = new FileInputStream(file)) {
  86
  87         fileContent = FileUtils.toByteArray(fis);
  88
  89         if (file.getName().equals(MANIFEST_NAME)) {
  90           heatToToscaTranslator.addManifest(MANIFEST_NAME, fileContent);
  91         } else {
  92           if (!file.getName().equals(zipFilename) && (!file.getName().equals(validationFilename))) {
  93             heatToToscaTranslator.addFile(file.getName(), fileContent);
  94           }
  95         }
  96       }
  97     }
  98   }
  99
 100   /**
 101    * Get tosca service template models for the files in a directory
 102    *
 103    * @param baseDirPath base directory for the tosca file
 104    * @return Map of <ServiceTemplateFilename, ServiceTemplate> for the files in this directory
 105    */
 106   private static Map<String, ServiceTemplate> getServiceTemplates(String baseDirPath) throws URISyntaxException{
 107     Map<String, ServiceTemplate> serviceTemplateMap = new HashMap<>();
 108     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 109     baseDirPath = "." + baseDirPath + "/";
 110
 111       String[] fileList = {};
 112       URL filesDirUrl = TestUtils.class.getClassLoader().getResource(baseDirPath);
 113       if (filesDirUrl != null && filesDirUrl.getProtocol().equals("file")) {
 114         fileList = new File(filesDirUrl.toURI()).list();
 115       } else {
 116         Assert.fail("Invalid expected output files directory");
 117       }
 118       for (String fileName : fileList) {
 119
 120         URL resource = TestUtils.class.getClassLoader().getResource(baseDirPath + fileName);
 121         ServiceTemplate serviceTemplate = FileUtils.readViaInputStream(resource,
 122                 stream -> toscaExtensionYamlUtil.yamlToObject(stream, ServiceTemplate.class));
 123
 124         serviceTemplateMap.put(fileName, serviceTemplate);
 125       }
 126     return serviceTemplateMap;
 127   }
 128   /**
 129    * Get tosca service template models
 130    *
 131    * @param expectedResultMap Map of filename and payload of the expected result files
 132    * @return Map of <ServiceTemplateFilename, ServiceTemplate> for the files in this directory
 133    */
 134   public static Map<String, ServiceTemplate> getServiceTemplates(Map<String, byte[]>
 135                                                                      expectedResultMap) {
 136     Map<String, ServiceTemplate> serviceTemplateMap = new HashMap<>();
 137     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 138     for (String fileName : expectedResultMap.keySet()) {
 139       ServiceTemplate serviceTemplate = toscaExtensionYamlUtil.yamlToObject
 140           (new String(expectedResultMap.get(fileName)), ServiceTemplate.class);
 141       serviceTemplateMap.put(fileName, serviceTemplate);
 142     }
 143     return serviceTemplateMap;
 144   }
 145
 146
 147   public static ToscaServiceModel loadToscaServiceModel(String serviceTemplatesPath,
 148                                                         String globalServiceTemplatesPath,
 149                                                         String entryDefinitionServiceTemplate)
 150       throws IOException, URISyntaxException {
 151     Map<String, ServiceTemplate> serviceTemplates;
 152     if (entryDefinitionServiceTemplate == null) {
 153       entryDefinitionServiceTemplate = "MainServiceTemplate.yaml";
 154     }
 155
 156     serviceTemplates = getServiceTemplates(serviceTemplatesPath);
 157     if (globalServiceTemplatesPath != null) {
 158       serviceTemplates = getServiceTemplates(globalServiceTemplatesPath);
 159     }
 160
 161     return new ToscaServiceModel(null, serviceTemplates, entryDefinitionServiceTemplate);
 162   }
 163
 164   public static ServiceTemplate loadServiceTemplate(String serviceTemplatePath)
 165       throws IOException {
 166     ServiceTemplate serviceTemplateFromYaml = new ServiceTemplate();
 167     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 168     URL urlFile = TestUtils.class.getResource(serviceTemplatePath);
 169     if (urlFile != null) {
 170       File pathFile = new File(urlFile.getFile());
 171       File[] files = pathFile.listFiles();
 172       for (File file : files) {
 173         try (InputStream yamlFile = new FileInputStream(file)) {
 174           serviceTemplateFromYaml =
 175               toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 176           createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml,
 177               toscaExtensionYamlUtil);
 178         }
 179       }
 180     } else {
 181       throw new NotDirectoryException(serviceTemplatePath);
 182     }
 183     return serviceTemplateFromYaml;
 184   }
 185
 186
 187   public static void loadServiceTemplates(String serviceTemplatesPath,
 188                                           ToscaExtensionYamlUtil toscaExtensionYamlUtil,
 189                                           Map<String, ServiceTemplate> serviceTemplates)
 190       throws IOException {
 191     URL urlFile = TestUtils.class.getResource(serviceTemplatesPath);
 192     if (urlFile != null) {
 193       File pathFile = new File(urlFile.getFile());
 194       File[] files = pathFile.listFiles();
 195       if (files != null) {
 196         addServiceTemplateFiles(serviceTemplates, files, toscaExtensionYamlUtil);
 197       } else {
 198         throw new NotDirectoryException(serviceTemplatesPath);
 199       }
 200     } else {
 201       throw new NotDirectoryException(serviceTemplatesPath);
 202     }
 203   }
 204
 205   private static void addServiceTemplateFiles(Map<String, ServiceTemplate> serviceTemplates,
 206                                               File[] files,
 207                                               ToscaExtensionYamlUtil toscaExtensionYamlUtil)
 208       throws IOException {
 209     for (File file : files) {
 210       try (InputStream yamlFile = new FileInputStream(file)) {
 211         ServiceTemplate serviceTemplateFromYaml =
 212             toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 213         createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml,
 214             toscaExtensionYamlUtil);
 215         serviceTemplates.put(file.getName(), serviceTemplateFromYaml);
 216       }
 217     }
 218   }
 219
 220   private static void createConcreteRequirementObjectsInServiceTemplate(ServiceTemplate
 221                                                                             serviceTemplateFromYaml,
 222                                                                         ToscaExtensionYamlUtil
 223                                                                             toscaExtensionYamlUtil) {
 224
 225     if (serviceTemplateFromYaml == null
 226         || serviceTemplateFromYaml.getTopology_template() == null
 227         || serviceTemplateFromYaml.getTopology_template().getNode_templates() == null) {
 228       return;
 229     }
 230
 231     //Creating concrete objects
 232     Map<String, NodeTemplate> nodeTemplates =
 233         serviceTemplateFromYaml.getTopology_template().getNode_templates();
 234     for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
 235       NodeTemplate nodeTemplate = entry.getValue();
 236       List<Map<String, RequirementAssignment>> requirements = nodeTemplate.getRequirements();
 237       List<Map<String, RequirementAssignment>> concreteRequirementList = new ArrayList<>();
 238       if (requirements != null) {
 239         ListIterator<Map<String, RequirementAssignment>> reqListIterator = requirements
 240             .listIterator();
 241         while (reqListIterator.hasNext()) {
 242           Map<String, RequirementAssignment> requirement = reqListIterator.next();
 243           Map<String, RequirementAssignment> concreteRequirement = new HashMap<>();
 244           for (Map.Entry<String, RequirementAssignment> reqEntry : requirement.entrySet()) {
 245             RequirementAssignment requirementAssignment = (toscaExtensionYamlUtil
 246                 .yamlToObject(toscaExtensionYamlUtil.objectToYaml(reqEntry.getValue()),
 247                     RequirementAssignment.class));
 248             concreteRequirement.put(reqEntry.getKey(), requirementAssignment);
 249             concreteRequirementList.add(concreteRequirement);
 250             reqListIterator.remove();
 251           }
 252         }
 253         requirements.clear();
 254         requirements.addAll(concreteRequirementList);
 255         nodeTemplate.setRequirements(requirements);
 256       }
 257       System.out.println();
 258       //toscaExtensionYamlUtil.yamlToObject(nodeTemplate, NodeTemplate.class);
 259     }
 260   }
 261
 262   public static void updateMultiplePortConsolidationDatas(String serviceTemplateName,
 263                                                           List<String> portNodeTemplateIds,
 264                                                           List<List<String>> nodesConnectedInIds,
 265                                                           List<List<String>> nodesConnectedOutIds,
 266                                                           List<List<String>> groupIds,
 267                                                           List<List<String>> getAttrInIds,
 268                                                           List<List<Pair<String, GetAttrFuncData>>> getAttrOutFuncDataList,
 269                                                           ConsolidationData consolidationData) {
 270     for (int i = 0; i < portNodeTemplateIds.size(); i++) {
 271       updatePortConsolidationData(serviceTemplateName, portNodeTemplateIds.get(i),
 272           nodesConnectedInIds.get(i), nodesConnectedOutIds.get(i),
 273           groupIds.get(i), getAttrInIds.get(i), getAttrOutFuncDataList.get(i), consolidationData);
 274     }
 275   }
 276
 277   public static void addPortSubInterface(
 278       SubInterfaceConsolidationDataTestInfo subInterfaceConsolidationDataTestInfo) {
 279     PortTemplateConsolidationData portTemplateConsolidationData =
 280         subInterfaceConsolidationDataTestInfo.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
 281             (subInterfaceConsolidationDataTestInfo.getServiceTemplateFileName()).getPortTemplateConsolidationData(
 282             subInterfaceConsolidationDataTestInfo.getPortNodeTemplateId());
 283
 284     SubInterfaceTemplateConsolidationData subInterface =
 285         new SubInterfaceTemplateConsolidationData();
 286     subInterface.setNodeTemplateId(subInterfaceConsolidationDataTestInfo.getSubInterfaceId());
 287     subInterface.setNetworkRole(subInterfaceConsolidationDataTestInfo.getNetworkRole());
 288     subInterface.setResourceGroupCount(
 289         subInterfaceConsolidationDataTestInfo.getResourceGroupCount());
 290
 291     updateRelationsForEntityConsolidationData(
 292         subInterfaceConsolidationDataTestInfo.getNodesConnectedIn(),
 293         subInterfaceConsolidationDataTestInfo.getNodesConnectedOut(), null,
 294         subInterfaceConsolidationDataTestInfo.getNodesGetAttrIn(),
 295         subInterfaceConsolidationDataTestInfo.getNodesGetAttrOut(), subInterface);
 296
 297     portTemplateConsolidationData.addSubInterfaceConsolidationData(
 298         subInterfaceConsolidationDataTestInfo.getSubInterfaceType(), subInterface);
 299
 300   }
 301
 302   public static void updatePortConsolidationData(String serviceTemplateFileName,
 303                                                  String portNodeTemplateId,
 304                                                  List<String> nodesConnectedInIds,
 305                                                  List<String> nodesConnectedOutIds,
 306                                                  List<String> groupIds, List<String> getAttrInIds,
 307                                                  List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
 308                                                  ConsolidationData consolidationData) {
 309
 310     PortTemplateConsolidationData portTemplateConsolidationData =
 311         createPortTemplateConsolidationData(portNodeTemplateId);
 312
 313     updateRelationsForEntityConsolidationData(nodesConnectedInIds,
 314         nodesConnectedOutIds, groupIds, getAttrInIds, getAttrOutFuncDataList,
 315         portTemplateConsolidationData);
 316
 317     consolidationData.getPortConsolidationData()
 318         .getFilePortConsolidationData(serviceTemplateFileName)
 319         .setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
 320   }
 321
 322   public static PortTemplateConsolidationData createPortTemplateConsolidationData(
 323       String portNodeTemplateId) {
 324     PortTemplateConsolidationData portTemplateConsolidationData =
 325         new PortTemplateConsolidationData();
 326     portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
 327     return portTemplateConsolidationData;
 328   }
 329
 330   public static void initPortConsolidationData(String serviceTemplateFileName,
 331                                                ConsolidationData consolidationData) {
 332
 333     consolidationData.getPortConsolidationData()
 334         .setFilePortConsolidationData(serviceTemplateFileName, new FilePortConsolidationData());
 335   }
 336
 337   public static void updateComputeTemplateConsolidationData(String serviceTemplateFileName,
 338                                                             String computeNodeTypeName,
 339                                                             String computeNodeTemplateId,
 340                                                             List<String> nodeIdsConnectedIn,
 341                                                             List<String> nodeIdsConnectedOut,
 342                                                             List<String> volumeIds,
 343                                                             List<String> groupIds,
 344                                                             List<String> getAttrInIds,
 345                                                             List<Pair<String, GetAttrFuncData>> getAttrOutIds,
 346                                                             List<Pair<String, String>> portTypeToIdList,
 347                                                             ConsolidationData consolidationData) {
 348
 349     initComputeNodeTemplateIdInConsolidationData(serviceTemplateFileName, computeNodeTypeName,
 350         computeNodeTemplateId, consolidationData);
 351
 352     Map<String, List<RequirementAssignmentData>> volumes =
 353         consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 354             (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName)
 355             .getComputeTemplateConsolidationData(computeNodeTemplateId).getVolumes();
 356
 357     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 358         createComputeTemplateConsolidationData(computeNodeTemplateId, portTypeToIdList, volumes);
 359
 360     updateRelationsForEntityConsolidationData(nodeIdsConnectedIn,
 361         nodeIdsConnectedOut, groupIds, getAttrInIds, getAttrOutIds,
 362         computeTemplateConsolidationData);
 363
 364     updateVolumes(computeTemplateConsolidationData, volumeIds);
 365
 366     consolidationData.getComputeConsolidationData()
 367         .getFileComputeConsolidationData(serviceTemplateFileName)
 368         .getTypeComputeConsolidationData(computeNodeTypeName)
 369         .setComputeTemplateConsolidationData(computeNodeTemplateId,
 370             computeTemplateConsolidationData);
 371   }
 372
 373   private static void updateRelationsForEntityConsolidationData(List<String> nodeIdsConnectedIn,
 374                                                                 List<String> nodeIdsConnectedOut,
 375                                                                 List<String> groupIds,
 376                                                                 List<String> getAttrInIds,
 377                                                                 List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
 378                                                                 EntityConsolidationData entity) {
 379     updateRelationsIn(entity, nodeIdsConnectedIn);
 380     updateRelationsOut(entity, nodeIdsConnectedOut);
 381     updateGetAttrIn(entity, getAttrInIds);
 382     updateGetAttrOut(entity, getAttrOutFuncDataList);
 383     entity.setGroupIds(groupIds);
 384   }
 385
 386   public static void initComputeNodeTemplateIdInConsolidationData(String serviceTemplateFileName,
 387                                                                   String computeNodeTypeName,
 388                                                                   String computeNodeTemplateId,
 389                                                                   ConsolidationData consolidationData) {
 390
 391     if (Objects
 392         .isNull(consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 393             (serviceTemplateFileName))) {
 394       consolidationData.getComputeConsolidationData().setFileComputeConsolidationData
 395           (serviceTemplateFileName, new FileComputeConsolidationData());
 396     }
 397     TypeComputeConsolidationData typeComputeConsolidationData =
 398         consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 399             (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName);
 400
 401     if (
 402         typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId) ==
 403             null) {
 404
 405       consolidationData.getComputeConsolidationData()
 406           .getFileComputeConsolidationData(serviceTemplateFileName)
 407           .getTypeComputeConsolidationData(computeNodeTypeName)
 408           .setComputeTemplateConsolidationData(computeNodeTemplateId,
 409               new ComputeTemplateConsolidationData());
 410
 411     }
 412   }
 413
 414   public static void updateNestedConsolidationData(String serviceTemplateName,
 415                                                    List<String> substitutionNodeTemplateIds,
 416                                                    ConsolidationData consolidationData) {
 417     if (Objects.isNull(consolidationData.getNestedConsolidationData())) {
 418       consolidationData.setNestedConsolidationData(new NestedConsolidationData());
 419     }
 420
 421     FileNestedConsolidationData fileNestedConsolidationData = new FileNestedConsolidationData();
 422     for (String substitutionNodeTemplateId : substitutionNodeTemplateIds) {
 423       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 424           new NestedTemplateConsolidationData();
 425       nestedTemplateConsolidationData.setNodeTemplateId(substitutionNodeTemplateId);
 426       fileNestedConsolidationData.setNestedTemplateConsolidationData(substitutionNodeTemplateId,
 427           nestedTemplateConsolidationData);
 428     }
 429     consolidationData.getNestedConsolidationData()
 430         .setFileNestedConsolidationData(serviceTemplateName, fileNestedConsolidationData);
 431   }
 432
 433   public static ComputeTemplateConsolidationData createComputeTemplateConsolidationData(
 434       String computeNodeTemplateId,
 435       List<Pair<String, String>> portTypeToIdList,
 436       Map<String, List<RequirementAssignmentData>> volumes) {
 437     ComputeTemplateConsolidationData compute = new ComputeTemplateConsolidationData();
 438     compute.setNodeTemplateId(computeNodeTemplateId);
 439     if (portTypeToIdList != null) {
 440       for (Pair<String, String> port : portTypeToIdList) {
 441         compute.addPort(port.getLeft(), port.getRight());
 442       }
 443     }
 444     compute.setVolumes(volumes);
 445     return compute;
 446   }
 447
 448   private static void updateRelationsIn(EntityConsolidationData entity,
 449                                         List<String> idsPontingTome) {
 450     if (CollectionUtils.isEmpty(idsPontingTome)) {
 451       return;
 452     }
 453
 454     for (String pointingId : idsPontingTome) {
 455       entity
 456           .addNodesConnectedIn(pointingId, entity.getNodeTemplateId(), new RequirementAssignment());
 457     }
 458   }
 459
 460   private static void updateRelationsOut(EntityConsolidationData entity,
 461                                          List<String> idsToUpdate) {
 462     if (CollectionUtils.isEmpty(idsToUpdate)) {
 463       return;
 464     }
 465
 466     for (String id : idsToUpdate) {
 467       entity.addNodesConnectedOut(id, id, new RequirementAssignment());
 468     }
 469   }
 470
 471   private static void updateGetAttrIn(EntityConsolidationData entity,
 472                                       List<String> idsToUpdate) {
 473     if (CollectionUtils.isEmpty(idsToUpdate)) {
 474       return;
 475     }
 476
 477     for (String id : idsToUpdate) {
 478       entity.addNodesGetAttrIn(id, new GetAttrFuncData());
 479     }
 480   }
 481
 482   private static void updateGetAttrOut(EntityConsolidationData entity,
 483                                        List<Pair<String, GetAttrFuncData>> getAttrOutIds) {
 484     if (CollectionUtils.isEmpty(getAttrOutIds)) {
 485       return;
 486     }
 487
 488     for (Pair<String, GetAttrFuncData> getAttrOutFunc : getAttrOutIds) {
 489       entity.addNodesGetAttrOut(getAttrOutFunc.getLeft(), getAttrOutFunc.getRight());
 490     }
 491   }
 492
 493   private static void updateVolumes(ComputeTemplateConsolidationData compute,
 494                                     List<String> volumeIds) {
 495     if (CollectionUtils.isEmpty(volumeIds)) {
 496       return;
 497     }
 498
 499     for (String id : volumeIds) {
 500       RequirementAssignment requirementAssignment = new RequirementAssignment();
 501       requirementAssignment.setNode(id);
 502       compute.addVolume(id, requirementAssignment);
 503     }
 504   }
 505
 506   public static void initComputeNodeTypeInConsolidationData(String serviceTemplateFileName,
 507                                                             String computeNodeTypeName,
 508                                                             ConsolidationData consolidationData) {
 509     ComputeConsolidationData computeConsolidationData =
 510         consolidationData.getComputeConsolidationData();
 511     if (!computeConsolidationData.getAllServiceTemplateFileNames()
 512         .contains(serviceTemplateFileName)) {
 513       computeConsolidationData
 514           .setFileComputeConsolidationData(serviceTemplateFileName,
 515               new FileComputeConsolidationData());
 516     }
 517     computeConsolidationData
 518         .getFileComputeConsolidationData(serviceTemplateFileName).setTypeComputeConsolidationData(
 519         computeNodeTypeName, new TypeComputeConsolidationData());
 520   }
 521
 522   public static Map<String, List<RequirementAssignmentData>> getNodeConnectedOutList(
 523       NodeTemplate nodeTemplate, String requirementKey) {
 524     Map<String, List<RequirementAssignmentData>> requirementAssignmentDataMap = new HashMap<>();
 525     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
 526         TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
 527     if (requirementAssignmentDataList.isPresent()) {
 528       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 529           .get()) {
 530         String connectedNodeTemplateId = requirementAssignmentData.getRequirementAssignment()
 531             .getNode();
 532         requirementAssignmentDataMap
 533             .computeIfAbsent(connectedNodeTemplateId, k -> new ArrayList<>());
 534         requirementAssignmentDataMap.get(connectedNodeTemplateId).add(requirementAssignmentData);
 535       }
 536     }
 537     return requirementAssignmentDataMap;
 538   }
 539
 540   public static Map<String, List<GetAttrFuncData>> getNodesGetAttrIn(NodeTemplate nodeTemplate,
 541                                                                      String nodeTemplateId) {
 542     Map<String, List<GetAttrFuncData>> nodesGetAttrIn = new HashMap<>();
 543     List<GetAttrFuncData> getAttrList = new ArrayList<>();
 544     ObjectMapper mapper = new ObjectMapper();
 545     Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
 546     for (Map.Entry<String, Object> propertyEntry : nodeTemplateProperties.entrySet()) {
 547       Map<String, List> propertyValue = mapper.convertValue(propertyEntry.getValue(), Map.class);
 548       for (Map.Entry<String, List> entry : propertyValue.entrySet()) {
 549         if (entry.getKey().equals("get_attribute")) {
 550           GetAttrFuncData data = new GetAttrFuncData();
 551           data.setFieldName(propertyEntry.getKey());
 552           data.setAttributeName(entry.getValue().get(1).toString());
 553           getAttrList.add(data);
 554         }
 555       }
 556       System.out.println();
 557     }
 558     nodesGetAttrIn.put(nodeTemplateId, getAttrList);
 559     return nodesGetAttrIn;
 560   }
 561
 562   public static void updatePortsInComputeTemplateConsolidationData(
 563       List<Pair<String, String>> portIdToTypeList, ComputeTemplateConsolidationData
 564       compute) {
 565     compute.setPorts(new HashMap<>());
 566     for (Pair<String, String> portIdToType : portIdToTypeList) {
 567       compute.getPorts().putIfAbsent(portIdToType.getLeft(), new ArrayList<>());
 568       compute.getPorts().get(portIdToType.getLeft()).add(portIdToType.getRight());
 569     }
 570   }
 571
 572   public static Map<String, List<RequirementAssignmentData>> getNodeConnectedInList(
 573       String sourceNodeTemplateId,
 574       ServiceTemplate serviceTemplate, String requirementKey) {
 575     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList = Optional.empty();
 576     List<RequirementAssignmentData> assignmentDataList = new ArrayList<>();
 577     Map<String, List<RequirementAssignmentData>> requirementAssignmentDataMap = new HashMap<>();
 578     Map<String, NodeTemplate> nodeTemplates = serviceTemplate.getTopology_template()
 579         .getNode_templates();
 580     for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
 581       String nodeTemplateId = entry.getKey();
 582       List<Map<String, RequirementAssignment>> requirements = entry.getValue().getRequirements();
 583       if (requirements != null) {
 584         for (Map<String, RequirementAssignment> requirement : requirements) {
 585           if (requirement.get(requirementKey) != null) {
 586             RequirementAssignment requirementAssignment = requirement.get(requirementKey);
 587             if (requirementAssignment != null) {
 588               if (requirementAssignment.getNode().equals(sourceNodeTemplateId)) {
 589                 RequirementAssignmentData data = new RequirementAssignmentData(requirementKey,
 590                     requirementAssignment);
 591                 assignmentDataList.add(data);
 592               }
 593             }
 594           }
 595         }
 596         requirementAssignmentDataList = Optional.ofNullable(assignmentDataList);
 597         if (requirementAssignmentDataList.isPresent()) {
 598           for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 599               .get()) {
 600             requirementAssignmentDataMap.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
 601             requirementAssignmentDataMap.get(nodeTemplateId).add(requirementAssignmentData);
 602           }
 603         }
 604         requirementAssignmentDataList = Optional.empty();
 605       }
 606     }
 607     return requirementAssignmentDataMap;
 608   }
 609
 610   public static List<String> getGroupsForNode(ServiceTemplate serviceTemplate, String
 611       nodeTemplateId) {
 612     List<String> entityGroups = new ArrayList<>();
 613     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
 614     for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
 615       String groupId = entry.getKey();
 616       GroupDefinition groupDefinition = entry.getValue();
 617       if (groupDefinition.getType().contains("HeatStack")) {
 618         continue;
 619       }
 620       List<String> groupMembers = groupDefinition.getMembers();
 621       for (String member : groupMembers) {
 622         if (groups.containsKey(member)) {
 623           continue;
 624         }
 625         if (member.equals(nodeTemplateId)) {
 626           entityGroups.add(groupId);
 627         }
 628       }
 629     }
 630     return entityGroups;
 631   }
 632
 633   private static Optional<List<RequirementAssignmentData>> createRequirementAssignmentDataList(
 634       NodeTemplate nodeTemplate, String requirementKey) {
 635
 636     Optional<List<RequirementAssignment>> requirementAssignmentLink =
 637         DataModelUtil.getRequirementAssignment(nodeTemplate.getRequirements(), requirementKey);
 638     if (!requirementAssignmentLink.isPresent()) {
 639       return Optional.empty();
 640     }
 641
 642     List<RequirementAssignmentData> requirementAssignmentDataList = new ArrayList<>();
 643     for (RequirementAssignment requirementAssignment : requirementAssignmentLink.get()) {
 644       RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData
 645           (requirementKey, requirementAssignment);
 646       requirementAssignmentDataList.add(requirementAssignmentData);
 647     }
 648     return Optional.ofNullable(requirementAssignmentDataList);
 649   }
 650
 651   public static Optional<List<RequirementAssignmentData>> getRequirementAssignmentDataList(
 652       NodeTemplate nodeTemplate, String requirementKey) {
 653     List<RequirementAssignmentData> returnedReqAssignmentDataList = new ArrayList<>();
 654     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
 655         TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
 656
 657     if (requirementAssignmentDataList.isPresent()) {
 658       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 659           .get()) {
 660         returnedReqAssignmentDataList.add(requirementAssignmentData);
 661       }
 662       return Optional.of(returnedReqAssignmentDataList);
 663     }
 664     return Optional.empty();
 665   }
 666
 667   public static ServiceTemplate createInitServiceTemplate() {
 668     ServiceTemplate initServiceTemplate = new ServiceTemplate();
 669     Map<String, String> templateMetadata = new HashMap<>();
 670     templateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, "Test");
 671     initServiceTemplate.setTosca_definitions_version(ToscaConstants.TOSCA_DEFINITIONS_VERSION);
 672     initServiceTemplate.setMetadata(templateMetadata);
 673     initServiceTemplate.setTopology_template(new TopologyTemplate());
 674     initServiceTemplate.setImports(GlobalTypesGenerator.getGlobalTypesImportList());
 675     return initServiceTemplate;
 676   }
 677
 678 }