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 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 org.codehaus.jackson.map.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<List<String>> nodesConnectedInIds,
 274                                                           List<List<String>> nodesConnectedOutIds,
 275                                                           List<List<String>> groupIds,
 276                                                           List<List<String>> getAttrInIds,
 277                                                           List<List<Pair<String, GetAttrFuncData>>> getAttrOutFuncDataList,
 278                                                           ConsolidationData consolidationData) {
 279     for (int i = 0; i < portNodeTemplateIds.size(); i++) {
 280       updatePortConsolidationData(serviceTemplateName, portNodeTemplateIds.get(i),
 281           nodesConnectedInIds.get(i), nodesConnectedOutIds.get(i),
 282           groupIds.get(i), getAttrInIds.get(i), getAttrOutFuncDataList.get(i), consolidationData);
 283     }
 284   }
 285
 286   public static void addPortSubInterface(
 287       SubInterfaceConsolidationDataTestInfo subInterfaceConsolidationDataTestInfo) {
 288     PortTemplateConsolidationData portTemplateConsolidationData =
 289         subInterfaceConsolidationDataTestInfo.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
 290             (subInterfaceConsolidationDataTestInfo.getServiceTemplateFileName()).getPortTemplateConsolidationData(
 291             subInterfaceConsolidationDataTestInfo.getPortNodeTemplateId());
 292
 293     SubInterfaceTemplateConsolidationData subInterface =
 294         new SubInterfaceTemplateConsolidationData();
 295     subInterface.setNodeTemplateId(subInterfaceConsolidationDataTestInfo.getSubInterfaceId());
 296     subInterface.setNetworkRole(subInterfaceConsolidationDataTestInfo.getNetworkRole());
 297     subInterface.setResourceGroupCount(
 298         subInterfaceConsolidationDataTestInfo.getResourceGroupCount());
 299
 300     updateRelationsForEntityConsolidationData(
 301         subInterfaceConsolidationDataTestInfo.getNodesConnectedIn(),
 302         subInterfaceConsolidationDataTestInfo.getNodesConnectedOut(), null,
 303         subInterfaceConsolidationDataTestInfo.getNodesGetAttrIn(),
 304         subInterfaceConsolidationDataTestInfo.getNodesGetAttrOut(), subInterface);
 305
 306     portTemplateConsolidationData.addSubInterfaceConsolidationData(
 307         subInterfaceConsolidationDataTestInfo.getSubInterfaceType(), subInterface);
 308
 309   }
 310
 311   public static void updatePortConsolidationData(String serviceTemplateFileName,
 312                                                  String portNodeTemplateId,
 313                                                  List<String> nodesConnectedInIds,
 314                                                  List<String> nodesConnectedOutIds,
 315                                                  List<String> groupIds, List<String> getAttrInIds,
 316                                                  List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
 317                                                  ConsolidationData consolidationData) {
 318
 319     PortTemplateConsolidationData portTemplateConsolidationData =
 320         createPortTemplateConsolidationData(portNodeTemplateId);
 321
 322     updateRelationsForEntityConsolidationData(nodesConnectedInIds,
 323         nodesConnectedOutIds, groupIds, getAttrInIds, getAttrOutFuncDataList,
 324         portTemplateConsolidationData);
 325
 326     consolidationData.getPortConsolidationData()
 327         .getFilePortConsolidationData(serviceTemplateFileName)
 328         .setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
 329   }
 330
 331   public static PortTemplateConsolidationData createPortTemplateConsolidationData(
 332       String portNodeTemplateId) {
 333     PortTemplateConsolidationData portTemplateConsolidationData =
 334         new PortTemplateConsolidationData();
 335     portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
 336     return portTemplateConsolidationData;
 337   }
 338
 339   public static void initPortConsolidationData(String serviceTemplateFileName,
 340                                                ConsolidationData consolidationData) {
 341
 342     consolidationData.getPortConsolidationData()
 343         .setFilePortConsolidationData(serviceTemplateFileName, new FilePortConsolidationData());
 344   }
 345
 346   public static void updateComputeTemplateConsolidationData(String serviceTemplateFileName,
 347                                                             String computeNodeTypeName,
 348                                                             String computeNodeTemplateId,
 349                                                             List<String> nodeIdsConnectedIn,
 350                                                             List<String> nodeIdsConnectedOut,
 351                                                             List<String> volumeIds,
 352                                                             List<String> groupIds,
 353                                                             List<String> getAttrInIds,
 354                                                             List<Pair<String, GetAttrFuncData>> getAttrOutIds,
 355                                                             List<Pair<String, String>> portTypeToIdList,
 356                                                             ConsolidationData consolidationData) {
 357
 358     initComputeNodeTemplateIdInConsolidationData(serviceTemplateFileName, computeNodeTypeName,
 359         computeNodeTemplateId, consolidationData);
 360
 361       Multimap<String, RequirementAssignmentData> volumes =
 362         consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 363             (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName)
 364             .getComputeTemplateConsolidationData(computeNodeTemplateId).getVolumes();
 365
 366     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 367         createComputeTemplateConsolidationData(computeNodeTemplateId, portTypeToIdList, volumes);
 368
 369     updateRelationsForEntityConsolidationData(nodeIdsConnectedIn,
 370         nodeIdsConnectedOut, groupIds, getAttrInIds, getAttrOutIds,
 371         computeTemplateConsolidationData);
 372
 373     updateVolumes(computeTemplateConsolidationData, volumeIds);
 374
 375     consolidationData.getComputeConsolidationData()
 376         .getFileComputeConsolidationData(serviceTemplateFileName)
 377         .getTypeComputeConsolidationData(computeNodeTypeName)
 378         .setComputeTemplateConsolidationData(computeNodeTemplateId,
 379             computeTemplateConsolidationData);
 380   }
 381
 382   private static void updateRelationsForEntityConsolidationData(List<String> nodeIdsConnectedIn,
 383                                                                 List<String> nodeIdsConnectedOut,
 384                                                                 List<String> groupIds,
 385                                                                 List<String> getAttrInIds,
 386                                                                 List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
 387                                                                 EntityConsolidationData entity) {
 388     updateRelationsIn(entity, nodeIdsConnectedIn);
 389     updateRelationsOut(entity, nodeIdsConnectedOut);
 390     updateGetAttrIn(entity, getAttrInIds);
 391     updateGetAttrOut(entity, getAttrOutFuncDataList);
 392     entity.setGroupIds(groupIds);
 393   }
 394
 395   public static void initComputeNodeTemplateIdInConsolidationData(String serviceTemplateFileName,
 396                                                                   String computeNodeTypeName,
 397                                                                   String computeNodeTemplateId,
 398                                                                   ConsolidationData consolidationData) {
 399
 400     if (Objects
 401         .isNull(consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 402             (serviceTemplateFileName))) {
 403       consolidationData.getComputeConsolidationData().setFileComputeConsolidationData
 404           (serviceTemplateFileName, new FileComputeConsolidationData());
 405     }
 406     TypeComputeConsolidationData typeComputeConsolidationData =
 407         consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 408             (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName);
 409
 410     if (
 411         typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId) ==
 412             null) {
 413
 414       consolidationData.getComputeConsolidationData()
 415           .getFileComputeConsolidationData(serviceTemplateFileName)
 416           .getTypeComputeConsolidationData(computeNodeTypeName)
 417           .setComputeTemplateConsolidationData(computeNodeTemplateId,
 418               new ComputeTemplateConsolidationData());
 419
 420     }
 421   }
 422
 423   public static void updateNestedConsolidationData(String serviceTemplateName,
 424                                                    List<String> substitutionNodeTemplateIds,
 425                                                    ConsolidationData consolidationData) {
 426     if (Objects.isNull(consolidationData.getNestedConsolidationData())) {
 427       consolidationData.setNestedConsolidationData(new NestedConsolidationData());
 428     }
 429
 430     FileNestedConsolidationData fileNestedConsolidationData = new FileNestedConsolidationData();
 431     for (String substitutionNodeTemplateId : substitutionNodeTemplateIds) {
 432       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 433           new NestedTemplateConsolidationData();
 434       nestedTemplateConsolidationData.setNodeTemplateId(substitutionNodeTemplateId);
 435       fileNestedConsolidationData.setNestedTemplateConsolidationData(substitutionNodeTemplateId,
 436           nestedTemplateConsolidationData);
 437     }
 438     consolidationData.getNestedConsolidationData()
 439         .setFileNestedConsolidationData(serviceTemplateName, fileNestedConsolidationData);
 440   }
 441
 442   public static ComputeTemplateConsolidationData createComputeTemplateConsolidationData(
 443       String computeNodeTemplateId,
 444       List<Pair<String, String>> portTypeToIdList,
 445       Multimap<String, RequirementAssignmentData> volumes) {
 446     ComputeTemplateConsolidationData compute = new ComputeTemplateConsolidationData();
 447     compute.setNodeTemplateId(computeNodeTemplateId);
 448     if (portTypeToIdList != null) {
 449       for (Pair<String, String> port : portTypeToIdList) {
 450         compute.addPort(port.getLeft(), port.getRight());
 451       }
 452     }
 453     compute.setVolumes(volumes);
 454     return compute;
 455   }
 456
 457   private static void updateRelationsIn(EntityConsolidationData entity,
 458                                         List<String> idsPontingTome) {
 459     if (CollectionUtils.isEmpty(idsPontingTome)) {
 460       return;
 461     }
 462
 463     for (String pointingId : idsPontingTome) {
 464       entity
 465           .addNodesConnectedIn(pointingId, entity.getNodeTemplateId(), new RequirementAssignment());
 466     }
 467   }
 468
 469   private static void updateRelationsOut(EntityConsolidationData entity,
 470                                          List<String> idsToUpdate) {
 471     if (CollectionUtils.isEmpty(idsToUpdate)) {
 472       return;
 473     }
 474
 475     for (String id : idsToUpdate) {
 476       entity.addNodesConnectedOut(id, id, new RequirementAssignment());
 477     }
 478   }
 479
 480   private static void updateGetAttrIn(EntityConsolidationData entity,
 481                                       List<String> idsToUpdate) {
 482     if (CollectionUtils.isEmpty(idsToUpdate)) {
 483       return;
 484     }
 485
 486     for (String id : idsToUpdate) {
 487       entity.addNodesGetAttrIn(id, new GetAttrFuncData());
 488     }
 489   }
 490
 491   private static void updateGetAttrOut(EntityConsolidationData entity,
 492                                        List<Pair<String, GetAttrFuncData>> getAttrOutIds) {
 493     if (CollectionUtils.isEmpty(getAttrOutIds)) {
 494       return;
 495     }
 496
 497     for (Pair<String, GetAttrFuncData> getAttrOutFunc : getAttrOutIds) {
 498       entity.addNodesGetAttrOut(getAttrOutFunc.getLeft(), getAttrOutFunc.getRight());
 499     }
 500   }
 501
 502   private static void updateVolumes(ComputeTemplateConsolidationData compute,
 503                                     List<String> volumeIds) {
 504     if (CollectionUtils.isEmpty(volumeIds)) {
 505       return;
 506     }
 507
 508     for (String id : volumeIds) {
 509       RequirementAssignment requirementAssignment = new RequirementAssignment();
 510       requirementAssignment.setNode(id);
 511       compute.addVolume(id, requirementAssignment);
 512     }
 513   }
 514
 515   public static void initComputeNodeTypeInConsolidationData(String serviceTemplateFileName,
 516                                                             String computeNodeTypeName,
 517                                                             ConsolidationData consolidationData) {
 518     ComputeConsolidationData computeConsolidationData =
 519         consolidationData.getComputeConsolidationData();
 520     if (!computeConsolidationData.getAllServiceTemplateFileNames()
 521         .contains(serviceTemplateFileName)) {
 522       computeConsolidationData
 523           .setFileComputeConsolidationData(serviceTemplateFileName,
 524               new FileComputeConsolidationData());
 525     }
 526     computeConsolidationData
 527         .getFileComputeConsolidationData(serviceTemplateFileName).setTypeComputeConsolidationData(
 528         computeNodeTypeName, new TypeComputeConsolidationData());
 529   }
 530
 531   public static Multimap<String, RequirementAssignmentData> getNodeConnectedOutList(
 532       NodeTemplate nodeTemplate, String requirementKey) {
 533       Multimap<String, RequirementAssignmentData> requirementAssignmentDataMap = ArrayListMultimap.create();
 534     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
 535         TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
 536     if (requirementAssignmentDataList.isPresent()) {
 537       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 538           .get()) {
 539         String connectedNodeTemplateId = requirementAssignmentData.getRequirementAssignment()
 540             .getNode();
 541         requirementAssignmentDataMap.put(connectedNodeTemplateId, requirementAssignmentData);
 542       }
 543     }
 544     return requirementAssignmentDataMap;
 545   }
 546
 547   public static Map<String, List<GetAttrFuncData>> getNodesGetAttrIn(NodeTemplate nodeTemplate,
 548                                                                      String nodeTemplateId) {
 549     Map<String, List<GetAttrFuncData>> nodesGetAttrIn = new HashMap<>();
 550     List<GetAttrFuncData> getAttrList = new ArrayList<>();
 551     ObjectMapper mapper = new ObjectMapper();
 552     Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
 553     for (Map.Entry<String, Object> propertyEntry : nodeTemplateProperties.entrySet()) {
 554       Map<String, List> propertyValue = mapper.convertValue(propertyEntry.getValue(), Map.class);
 555       for (Map.Entry<String, List> entry : propertyValue.entrySet()) {
 556         if (entry.getKey().equals("get_attribute")) {
 557           GetAttrFuncData data = new GetAttrFuncData();
 558           data.setFieldName(propertyEntry.getKey());
 559           data.setAttributeName(entry.getValue().get(1).toString());
 560           getAttrList.add(data);
 561         }
 562       }
 563       System.out.println();
 564     }
 565     nodesGetAttrIn.put(nodeTemplateId, getAttrList);
 566     return nodesGetAttrIn;
 567   }
 568
 569   public static void updatePortsInComputeTemplateConsolidationData(
 570       List<Pair<String, String>> portIdToTypeList, ComputeTemplateConsolidationData
 571       compute) {
 572     compute.setPorts(new HashMap<>());
 573     for (Pair<String, String> portIdToType : portIdToTypeList) {
 574       compute.getPorts().putIfAbsent(portIdToType.getLeft(), new ArrayList<>());
 575       compute.getPorts().get(portIdToType.getLeft()).add(portIdToType.getRight());
 576     }
 577   }
 578
 579   public static Multimap<String, RequirementAssignmentData> getNodeConnectedInList(
 580       String sourceNodeTemplateId,
 581       ServiceTemplate serviceTemplate, String requirementKey) {
 582     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList;
 583     List<RequirementAssignmentData> assignmentDataList = new ArrayList<>();
 584       Multimap<String, RequirementAssignmentData> requirementAssignmentDataMap = ArrayListMultimap.create();
 585     Map<String, NodeTemplate> nodeTemplates = serviceTemplate.getTopology_template()
 586         .getNode_templates();
 587     for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
 588       String nodeTemplateId = entry.getKey();
 589       List<Map<String, RequirementAssignment>> requirements = entry.getValue().getRequirements();
 590       if (requirements != null) {
 591         for (Map<String, RequirementAssignment> requirement : requirements) {
 592           if (requirement.get(requirementKey) != null) {
 593             RequirementAssignment requirementAssignment = requirement.get(requirementKey);
 594             if (requirementAssignment != null) {
 595               if (requirementAssignment.getNode().equals(sourceNodeTemplateId)) {
 596                 RequirementAssignmentData data = new RequirementAssignmentData(requirementKey,
 597                     requirementAssignment);
 598                 assignmentDataList.add(data);
 599               }
 600             }
 601           }
 602         }
 603         requirementAssignmentDataList = Optional.ofNullable(assignmentDataList);
 604         if (requirementAssignmentDataList.isPresent()) {
 605           for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 606               .get()) {
 607             requirementAssignmentDataMap.put(nodeTemplateId, requirementAssignmentData);
 608           }
 609         }
 610         requirementAssignmentDataList = Optional.empty();
 611       }
 612     }
 613     return requirementAssignmentDataMap;
 614   }
 615
 616   public static List<String> getGroupsForNode(ServiceTemplate serviceTemplate, String
 617       nodeTemplateId) {
 618     List<String> entityGroups = new ArrayList<>();
 619     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
 620     for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
 621       String groupId = entry.getKey();
 622       GroupDefinition groupDefinition = entry.getValue();
 623       if (groupDefinition.getType().contains("HeatStack")) {
 624         continue;
 625       }
 626       List<String> groupMembers = groupDefinition.getMembers();
 627       for (String member : groupMembers) {
 628         if (groups.containsKey(member)) {
 629           continue;
 630         }
 631         if (member.equals(nodeTemplateId)) {
 632           entityGroups.add(groupId);
 633         }
 634       }
 635     }
 636     return entityGroups;
 637   }
 638
 639   private static Optional<List<RequirementAssignmentData>> createRequirementAssignmentDataList(
 640       NodeTemplate nodeTemplate, String requirementKey) {
 641
 642     Optional<List<RequirementAssignment>> requirementAssignmentLink =
 643         DataModelUtil.getRequirementAssignment(nodeTemplate.getRequirements(), requirementKey);
 644     if (!requirementAssignmentLink.isPresent()) {
 645       return Optional.empty();
 646     }
 647
 648     List<RequirementAssignmentData> requirementAssignmentDataList = new ArrayList<>();
 649     for (RequirementAssignment requirementAssignment : requirementAssignmentLink.get()) {
 650       RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData
 651           (requirementKey, requirementAssignment);
 652       requirementAssignmentDataList.add(requirementAssignmentData);
 653     }
 654     return Optional.ofNullable(requirementAssignmentDataList);
 655   }
 656
 657   public static Optional<List<RequirementAssignmentData>> getRequirementAssignmentDataList(
 658       NodeTemplate nodeTemplate, String requirementKey) {
 659     List<RequirementAssignmentData> returnedReqAssignmentDataList = new ArrayList<>();
 660     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
 661         TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
 662
 663     if (requirementAssignmentDataList.isPresent()) {
 664       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 665           .get()) {
 666         returnedReqAssignmentDataList.add(requirementAssignmentData);
 667       }
 668       return Optional.of(returnedReqAssignmentDataList);
 669     }
 670     return Optional.empty();
 671   }
 672
 673   public static ServiceTemplate createInitServiceTemplate() {
 674     ServiceTemplate initServiceTemplate = new ServiceTemplate();
 675     Map<String, String> templateMetadata = new HashMap<>();
 676     templateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, "Test");
 677     initServiceTemplate.setTosca_definitions_version(ToscaConstants.TOSCA_DEFINITIONS_VERSION);
 678     initServiceTemplate.setMetadata(templateMetadata);
 679     initServiceTemplate.setTopology_template(new TopologyTemplate());
 680     initServiceTemplate.setImports(GlobalTypesGenerator.getGlobalTypesImportList());
 681     return initServiceTemplate;
 682   }
 683
 684   public static void compareTranslatedOutput(Set<String> expectedResultFileNameSet,
 685                                       Map<String, byte[]> expectedResultMap,
 686                                       ZipInputStream zis) throws IOException {
 687     ZipEntry entry;
 688     String name;
 689     String expected;
 690     String actual;
 691
 692     while ((entry = zis.getNextEntry()) != null) {
 693
 694       name = entry.getName()
 695               .substring(entry.getName().lastIndexOf(File.separator) + 1, entry.getName().length());
 696       if (expectedResultFileNameSet.contains(name)) {
 697         expected = new String(expectedResultMap.get(name)).trim().replace("\r", "");
 698         actual = new String(FileUtils.toByteArray(zis)).trim().replace("\r", "");
 699         assertEquals("difference in file: " + name, expected, actual);
 700
 701         expectedResultFileNameSet.remove(name);
 702       }
 703     }
 704     if (expectedResultFileNameSet.isEmpty()) {
 705       expectedResultFileNameSet.forEach(System.out::println);
 706     }
 707   }
 708
 709   public static String getErrorAsString(Map<String, List<ErrorMessage>> errorMessages) {
 710     StringBuilder sb = new StringBuilder();
 711     errorMessages.forEach((file, errorList) -> sb.append("File:").append(file).append(System.lineSeparator())
 712             .append(getErrorList(errorList)));
 713
 714     return sb.toString();
 715   }
 716
 717   private static String getErrorList(List<ErrorMessage> errors) {
 718     StringBuilder sb = new StringBuilder();
 719     errors.forEach(error -> sb.append(error.getMessage()).append("[").append(error.getLevel()).append("]")
 720             .append(System.lineSeparator()));
 721     return sb.toString();
 722   }
 723 }