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

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