openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/BaseResourceTranslationTest.java

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on a "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.services.heattotosca.impl.resourcetranslation;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.openecomp.sdc.common.utils.SdcCommon.MANIFEST_NAME;
  21 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateComputeConnectivityIn;
  22 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateComputeConnectivityOut;
  23 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateDependsOnInConsolidationData;
  24 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateGetAttr;
  25 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateGroupsInConsolidationData;
  26 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateNestedConsolidationData;
  27 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateNestedConsolidationDataNodeTemplateIds;
  28 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validatePortConnectivityIn;
  29 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validatePortConnectivityOut;
  30 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validatePortsInConsolidationData;
  31 import static org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataTestUtil.validateVolumeInConsolidationData;
  32
  33 import java.io.BufferedInputStream;
  34 import java.io.ByteArrayInputStream;
  35 import java.io.File;
  36 import java.io.FileInputStream;
  37 import java.io.IOException;
  38 import java.net.URL;
  39 import java.util.Collection;
  40 import java.util.HashMap;
  41 import java.util.HashSet;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.Set;
  45 import java.util.zip.ZipInputStream;
  46 import org.apache.commons.collections4.MapUtils;
  47 import org.junit.Assert;
  48 import org.junit.Before;
  49 import org.junit.BeforeClass;
  50 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  51 import org.openecomp.core.translator.datatypes.TranslatorOutput;
  52 import org.openecomp.core.utilities.file.FileUtils;
  53 import org.openecomp.core.utilities.json.JsonUtil;
  54 import org.openecomp.core.validation.util.MessageContainerUtil;
  55 import org.openecomp.sdc.be.togglz.ToggleableFeature;
  56 import org.openecomp.sdc.common.errors.CoreException;
  57 import org.openecomp.sdc.common.errors.ErrorCategory;
  58 import org.openecomp.sdc.common.errors.ErrorCode;
  59 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  60 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  61 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  62 import org.openecomp.sdc.heat.datatypes.manifest.ManifestFile;
  63 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
  64 import org.openecomp.sdc.translator.TestUtils;
  65 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  66 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  67 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  68 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  69 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  70 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  71 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  72 import org.openecomp.sdc.translator.services.heattotosca.TranslationService;
  73 import org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataValidationType;
  74 import org.togglz.testing.TestFeatureManager;
  75 import org.togglz.testing.TestFeatureManagerProvider;
  76
  77
  78 public class BaseResourceTranslationTest {
  79
  80     protected String inputFilesPath;
  81     protected String outputFilesPath;
  82     TranslationContext translationContext;
  83
  84     private TranslationService translationService;
  85     private byte[] translatedZipFile;
  86
  87     private Map<String, byte[]> expectedResultMap = new HashMap<>();
  88     private Set<String> expectedResultFileNameSet = new HashSet<>();
  89
  90     protected static TestFeatureManager manager;
  91
  92     @BeforeClass
  93     public static void enableToggleableFeatures() {
  94         manager = new TestFeatureManager(ToggleableFeature.class);
  95         manager.enableAll();
  96         TestFeatureManagerProvider.setFeatureManager(manager);
  97     }
  98
  99     @Before
 100     public void setUp() throws IOException {
 101         initTranslatorAndTranslate();
 102     }
 103
 104
 105     protected void initTranslatorAndTranslate() throws IOException {
 106         translationService = new TranslationService();
 107         translationContext = new TranslationContext();
 108         translatedZipFile = translateZipFile();
 109     }
 110
 111     protected void testTranslation() throws IOException {
 112
 113         URL url = BaseResourceTranslationTest.class.getResource(outputFilesPath);
 114
 115         String path = url.getPath();
 116         File pathFile = new File(path);
 117         File[] files = pathFile.listFiles();
 118         Assert.assertNotNull("manifest files is empty", files);
 119         for (File expectedFile : files) {
 120             expectedResultFileNameSet.add(expectedFile.getName());
 121             try (FileInputStream input = new FileInputStream(expectedFile)) {
 122                 expectedResultMap.put(expectedFile.getName(), FileUtils.toByteArray(input));
 123             }
 124         }
 125
 126         try (ByteArrayInputStream fis = new ByteArrayInputStream(translatedZipFile);
 127              BufferedInputStream bis = new BufferedInputStream(fis); ZipInputStream zis = new ZipInputStream(bis)) {
 128             TestUtils.compareTranslatedOutput(expectedResultFileNameSet, expectedResultMap, zis);
 129         }
 130         assertEquals(0, expectedResultFileNameSet.size());
 131     }
 132
 133     private byte[] translateZipFile() throws IOException {
 134         URL inputFilesUrl = this.getClass().getResource(inputFilesPath);
 135         String path = inputFilesUrl.getPath();
 136         addFilesToTranslator(translationContext, path);
 137         TranslatorOutput translatorOutput = translationService.translateHeatFiles(translationContext);
 138         Assert.assertNotNull(translatorOutput);
 139         if (MapUtils.isNotEmpty(translatorOutput.getErrorMessages()) && MapUtils.isNotEmpty(
 140                 MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, translatorOutput.getErrorMessages()))) {
 141             throw new CoreException((new ErrorCode.ErrorCodeBuilder()).withMessage(
 142                     "Error in validation " + TestUtils.getErrorAsString(translatorOutput.getErrorMessages()))
 143                                             .withId("Validation Error").withCategory(ErrorCategory.APPLICATION)
 144                                             .build());
 145         }
 146
 147         return new ToscaFileOutputServiceCsarImpl().createOutputFile(translatorOutput.getToscaServiceModel(), null);
 148
 149     }
 150
 151
 152     private void addFilesToTranslator(TranslationContext translationContext, String path) throws IOException {
 153         File manifestFile = new File(path);
 154         File[] files = manifestFile.listFiles();
 155         byte[] fileContent;
 156
 157         Assert.assertNotNull("manifest files is empty", files);
 158
 159         for (File file : files) {
 160
 161             try (FileInputStream fis = new FileInputStream(file)) {
 162
 163                 fileContent = FileUtils.toByteArray(fis);
 164
 165                 if (file.getName().equals(MANIFEST_NAME)) {
 166                     addManifest(translationContext, fileContent);
 167                 } else {
 168                     String validationFilename = "validationOutput.json";
 169                     String zipFilename = "VSP.zip";
 170                     if (!file.getName().equals(zipFilename) && (!file.getName().equals(validationFilename))) {
 171                         addFile(translationContext, file.getName(), fileContent);
 172                     }
 173                 }
 174             }
 175         }
 176     }
 177
 178     private static void addManifest(TranslationContext translationContext, byte[] content) {
 179         ManifestContent manifestData = JsonUtil.json2Object(new String(content), ManifestContent.class);
 180         ManifestFile manifest = new ManifestFile();
 181         manifest.setName(MANIFEST_NAME);
 182         manifest.setContent(manifestData);
 183         translationContext.setManifest(manifest);
 184         translationContext.addFile(MANIFEST_NAME, content);
 185         addFilesFromManifestToTranslationContextManifestFilesMap(translationContext, manifestData.getData());
 186     }
 187
 188     private static void addFile(TranslationContext translationContext, String name, byte[] content) {
 189         translationContext.addFile(name, content);
 190     }
 191
 192     private static void addFilesFromManifestToTranslationContextManifestFilesMap(TranslationContext translationContext,
 193             List<FileData> fileDataListFromManifest) {
 194         for (FileData fileFromManfiest : fileDataListFromManifest) {
 195             translationContext.addManifestFile(fileFromManfiest.getFile(), fileFromManfiest.getType());
 196         }
 197     }
 198
 199     void validateNodeTemplateIdInNestedConsolidationData() {
 200         ConsolidationData consolidationData = translationContext.getConsolidationData();
 201         Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates(expectedResultMap);
 202         Assert.assertNotNull(consolidationData);
 203         validateNestedConsolidationDataNodeTemplateIds(consolidationData, expectedServiceTemplateModels);
 204     }
 205
 206     protected void validateComputeTemplateConsolidationData(ConsolidationDataValidationType validationType,
 207             String testName) {
 208         ConsolidationData consolidationData = translationContext.getConsolidationData();
 209         Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates(expectedResultMap);
 210         Assert.assertNotNull(consolidationData);
 211         Assert.assertNotNull(consolidationData.getComputeConsolidationData());
 212         Set<String> serviceTemplateFileNames =
 213                 consolidationData.getComputeConsolidationData().getAllServiceTemplateFileNames();
 214         Assert.assertNotNull(serviceTemplateFileNames);
 215         for (String serviceTemplateName : serviceTemplateFileNames) {
 216             Assert.assertTrue(expectedServiceTemplateModels.containsKey(serviceTemplateName));
 217             ServiceTemplate expectedServiceTemplate = expectedServiceTemplateModels.get(serviceTemplateName);
 218             FileComputeConsolidationData fileComputeConsolidationData = consolidationData.getComputeConsolidationData()
 219                                                                                 .getFileComputeConsolidationData(
 220                                                                                         serviceTemplateName);
 221             Assert.assertNotNull(fileComputeConsolidationData);
 222             Set<String> computeTypes = fileComputeConsolidationData.getAllComputeTypes();
 223             Assert.assertNotNull(computeTypes);
 224             for (String computeType : computeTypes) {
 225                 TypeComputeConsolidationData typeComputeConsolidationData =
 226                         fileComputeConsolidationData.getTypeComputeConsolidationData(computeType);
 227                 Assert.assertNotNull(typeComputeConsolidationData);
 228
 229                 Collection<String> computeNodeTemplateIds = typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 230                 Assert.assertNotNull(computeNodeTemplateIds);
 231                 Assert.assertNotEquals(computeNodeTemplateIds.size(), 0);
 232
 233                 for (String computeNodeTemplateId : computeNodeTemplateIds) {
 234                     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 235                             typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
 236                     switch (validationType) {
 237                         case VALIDATE_GROUP:
 238                             validateGroupsInConsolidationData(computeNodeTemplateId, computeTemplateConsolidationData,
 239                                     expectedServiceTemplate);
 240                             break;
 241                         case VALIDATE_PORT:
 242                             validatePortsInConsolidationData(computeNodeTemplateId, computeTemplateConsolidationData,
 243                                     expectedServiceTemplate);
 244                             break;
 245                         case VALIDATE_VOLUME:
 246                             validateVolumeInConsolidationData(computeNodeTemplateId, computeTemplateConsolidationData,
 247                                     expectedServiceTemplate, testName);
 248                             break;
 249                         case VALIDATE_CONNECTIVITY:
 250                             validateComputeConnectivityIn(computeTemplateConsolidationData, expectedServiceTemplate);
 251                             validateComputeConnectivityOut(computeNodeTemplateId, computeTemplateConsolidationData,
 252                                     expectedServiceTemplate);
 253                             break;
 254                         case VALIDATE_DEPENDS_ON:
 255                             validateDependsOnInConsolidationData(computeNodeTemplateId,
 256                                     computeTemplateConsolidationData, expectedServiceTemplate, testName);
 257                             break;
 258                     }
 259                 }
 260             }
 261         }
 262     }
 263
 264     protected void validateGetAttribute(String testName) {
 265         validateGetAttr(translationContext, testName);
 266     }
 267
 268     protected void validateNestedTemplateConsolidationData(String testName) {
 269         validateNestedConsolidationData(translationContext, testName);
 270     }
 271
 272     void validatePortTemplateConsolidationData() {
 273         ConsolidationData consolidationData = translationContext.getConsolidationData();
 274         Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates(expectedResultMap);
 275         Assert.assertNotNull(consolidationData);
 276         Assert.assertNotNull(consolidationData.getPortConsolidationData());
 277         Set<String> serviceTemplateFileNames =
 278                 consolidationData.getPortConsolidationData().getAllServiceTemplateFileNames();
 279         Assert.assertNotNull(serviceTemplateFileNames);
 280         for (String serviceTemplateName : serviceTemplateFileNames) {
 281             Assert.assertTrue(expectedServiceTemplateModels.containsKey(serviceTemplateName));
 282             ServiceTemplate expectedServiceTemplate = expectedServiceTemplateModels.get(serviceTemplateName);
 283             FilePortConsolidationData filePortConsolidationData =
 284                     consolidationData.getPortConsolidationData().getFilePortConsolidationData(serviceTemplateName);
 285             Assert.assertNotNull(filePortConsolidationData);
 286
 287             Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
 288             Assert.assertNotNull(portNodeTemplateIds);
 289             Assert.assertNotEquals(portNodeTemplateIds.size(), 0);
 290
 291             for (String portNodeTemplateId : portNodeTemplateIds) {
 292                 PortTemplateConsolidationData portTemplateConsolidationData =
 293                         filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
 294                 switch (ConsolidationDataValidationType.VALIDATE_CONNECTIVITY) {
 295                     case VALIDATE_CONNECTIVITY:
 296                         validatePortConnectivityIn(portTemplateConsolidationData, expectedServiceTemplate);
 297                         validatePortConnectivityOut(portNodeTemplateId, portTemplateConsolidationData,
 298                                 expectedServiceTemplate);
 299                         break;
 300                 }
 301             }
 302         }
 303     }
 304 }