openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/TestUtils.java

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