gerrit.onap Code Review - sdc.git/blob

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