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