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 org.apache.commons.collections4.MapUtils;
  34 import org.junit.Assert;
  35 import org.junit.Before;
  36 import org.junit.BeforeClass;
  37 import org.junit.Rule;
  38 import org.junit.rules.TestName;
  39 import org.openecomp.core.translator.datatypes.TranslatorOutput;
  40 import org.openecomp.core.utilities.file.FileUtils;
  41 import org.openecomp.core.utilities.json.JsonUtil;
  42 import org.openecomp.core.validation.util.MessageContainerUtil;
  43 import org.openecomp.sdc.common.errors.CoreException;
  44 import org.openecomp.sdc.common.errors.ErrorCategory;
  45 import org.openecomp.sdc.common.errors.ErrorCode;
  46 import org.openecomp.sdc.common.togglz.ToggleableFeature;
  47 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  48 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  49 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  50 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  51 import org.openecomp.sdc.heat.datatypes.manifest.ManifestFile;
  52 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  53 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
  54 import org.openecomp.sdc.translator.TestUtils;
  55 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  56 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  57 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  58 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  59 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  60 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  61 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  62 import org.openecomp.sdc.translator.services.heattotosca.TranslationService;
  63 import org.openecomp.sdc.translator.services.heattotosca.buildconsolidationdata.ConsolidationDataValidationType;
  64 import org.togglz.testing.TestFeatureManager;
  65 import org.togglz.testing.TestFeatureManagerProvider;
  66
  67
  68 import java.io.*;
  69 import java.net.URL;
  70 import java.util.Collection;
  71 import java.util.HashMap;
  72 import java.util.HashSet;
  73 import java.util.List;
  74 import java.util.Map;
  75 import java.util.Set;
  76 import java.util.zip.ZipEntry;
  77 import java.util.zip.ZipInputStream;
  78
  79
  80 public class BaseResourceTranslationTest {
  81
  82   protected String inputFilesPath;
  83   protected String outputFilesPath;
  84   protected TranslationContext translationContext;
  85
  86   @Rule
  87   public TestName name = new TestName();
  88
  89   private String zipFilename = "VSP.zip";
  90   private TranslationService translationService;
  91   private byte[] translatedZipFile;
  92
  93   private static File tempDir = new File(System.getProperty("java.io.tmpdir"));
  94
  95   private Map<String, byte[]> expectedResultMap = new HashMap<>();
  96   private Set<String> expectedResultFileNameSet = new HashSet<>();
  97
  98   protected static TestFeatureManager manager;
  99
 100   @BeforeClass
 101   public static void enableToggleableFeatures(){
 102     manager = new TestFeatureManager(ToggleableFeature.class);
 103     manager.enableAll();
 104   }
 105
 106   public static void disableToggleableFeatures() {
 107     manager.disableAll();
 108     manager = null;
 109     TestFeatureManagerProvider.setFeatureManager(null);
 110   }
 111
 112   @Before
 113   public void setUp() throws IOException {
 114     initTranslatorAndTranslate();
 115   }
 116
 117
 118   protected void initTranslatorAndTranslate() throws IOException {
 119     translationService = new TranslationService();
 120     translationContext = new TranslationContext();
 121     translatedZipFile = translateZipFile();
 122   }
 123
 124   protected void testTranslation() throws IOException {
 125
 126     URL url = BaseResourceTranslationTest.class.getResource(outputFilesPath);
 127
 128     String path = url.getPath();
 129     File pathFile = new File(path);
 130     File[] files = pathFile.listFiles();
 131     Assert.assertNotNull("manifest files is empty", files);
 132     for (File expectedFile : files) {
 133       expectedResultFileNameSet.add(expectedFile.getName());
 134       try (FileInputStream input = new FileInputStream(expectedFile)) {
 135         expectedResultMap.put(expectedFile.getName(), FileUtils.toByteArray(input));
 136       }
 137     }
 138
 139     try (ByteArrayInputStream fis = new ByteArrayInputStream(translatedZipFile); BufferedInputStream bis = new BufferedInputStream(fis);
 140          ZipInputStream zis = new ZipInputStream(bis)) {
 141       ZipEntry entry;
 142       String name;
 143       String expected;
 144       String actual;
 145
 146       while ((entry = zis.getNextEntry()) != null) {
 147
 148         name = entry.getName()
 149             .substring(entry.getName().lastIndexOf(File.separator) + 1, entry.getName().length());
 150         if (expectedResultFileNameSet.contains(name)) {
 151           expected = new String(expectedResultMap.get(name)).trim().replace("\r", "");
 152           actual = new String(FileUtils.toByteArray(zis)).trim().replace("\r", "");
 153           assertEquals("difference in file: " + name, expected, actual);
 154
 155           expectedResultFileNameSet.remove(name);
 156         }
 157       }
 158       if (expectedResultFileNameSet.isEmpty()) {
 159         expectedResultFileNameSet.forEach(System.out::println);
 160       }
 161     }
 162     assertEquals(0, expectedResultFileNameSet.size());
 163   }
 164
 165   private byte[] translateZipFile() throws IOException {
 166     URL inputFilesUrl = this.getClass().getResource(inputFilesPath);
 167     String path = inputFilesUrl.getPath();
 168     addFilesToTranslator(translationContext, path);
 169     TranslatorOutput translatorOutput = translationService.translateHeatFiles(translationContext);
 170     Assert.assertNotNull(translatorOutput);
 171     if (MapUtils.isNotEmpty(translatorOutput.getErrorMessages()) && MapUtils.isNotEmpty(
 172         MessageContainerUtil
 173             .getMessageByLevel(ErrorLevel.ERROR, translatorOutput.getErrorMessages()))) {
 174       throw new CoreException((new ErrorCode.ErrorCodeBuilder()).withMessage(
 175           "Error in validation " + getErrorAsString(translatorOutput.getErrorMessages()))
 176           .withId("Validation Error").withCategory(ErrorCategory.APPLICATION).build());
 177     }
 178
 179     byte[] data = new ToscaFileOutputServiceCsarImpl().createOutputFile(translatorOutput.getToscaServiceModel(), null);
 180
 181     return data;
 182   }
 183
 184
 185   private String getErrorAsString(Map<String, List<ErrorMessage>> errorMessages) {
 186     StringBuilder sb = new StringBuilder();
 187     errorMessages.entrySet().forEach(
 188         entry -> sb.append("File:").append(entry.getKey()).append(System.lineSeparator())
 189             .append(getErrorList(entry.getValue())));
 190
 191     return sb.toString();
 192   }
 193
 194   private String getErrorList(List<ErrorMessage> errors) {
 195     StringBuilder sb = new StringBuilder();
 196     errors.forEach(
 197         error -> sb.append(error.getMessage()).append("[").append(error.getLevel()).append("]")
 198             .append(System.lineSeparator()));
 199     return sb.toString();
 200   }
 201
 202   public void addFilesToTranslator(TranslationContext translationContext, String path)
 203       throws IOException {
 204     File manifestFile = new File(path);
 205     File[] files = manifestFile.listFiles();
 206     byte[] fileContent;
 207
 208     Assert.assertNotNull("manifest files is empty", files);
 209
 210     for (File file : files) {
 211
 212       try (FileInputStream fis = new FileInputStream(file)) {
 213
 214         fileContent = FileUtils.toByteArray(fis);
 215
 216         if (file.getName().equals(MANIFEST_NAME)) {
 217           addManifest(translationContext, MANIFEST_NAME, fileContent);
 218         } else {
 219           String validationFilename = "validationOutput.json";
 220           if (!file.getName().equals(zipFilename) && (!file.getName().equals(validationFilename))) {
 221             addFile(translationContext, file.getName(), fileContent);
 222           }
 223         }
 224       }
 225     }
 226   }
 227
 228   public static void addManifest(TranslationContext translationContext,
 229                                  String name, byte[] content) {
 230     ManifestContent manifestData = JsonUtil.json2Object(new String(content), ManifestContent.class);
 231     ManifestFile manifest = new ManifestFile();
 232     manifest.setName(name);
 233     manifest.setContent(manifestData);
 234     translationContext.setManifest(manifest);
 235     translationContext.addFile(name, content);
 236     addFilesFromManifestToTranslationContextManifestFilesMap(translationContext, manifestData
 237         .getData());
 238   }
 239
 240   public static void addFile(TranslationContext translationContext,
 241                              String name, byte[] content) {
 242     translationContext.addFile(name, content);
 243   }
 244
 245   private static void addFilesFromManifestToTranslationContextManifestFilesMap(
 246       TranslationContext translationContext, List<FileData> fileDataListFromManifest) {
 247     for (FileData fileFromManfiest : fileDataListFromManifest) {
 248       translationContext.addManifestFile(fileFromManfiest.getFile(), fileFromManfiest.getType());
 249     }
 250   }
 251
 252   public void validateNodeTemplateIdInNestedConsolidationData(){
 253     ConsolidationData consolidationData = translationContext.getConsolidationData();
 254     Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates
 255         (expectedResultMap);
 256     Assert.assertNotNull(consolidationData);
 257     validateNestedConsolidationDataNodeTemplateIds(consolidationData,expectedServiceTemplateModels);
 258   }
 259
 260   public void validateComputeTemplateConsolidationData(ConsolidationDataValidationType
 261                                                            validationType,
 262                                                        String testName) {
 263     ConsolidationData consolidationData = translationContext.getConsolidationData();
 264     Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates
 265         (expectedResultMap);
 266     Assert.assertNotNull(consolidationData);
 267     Assert.assertNotNull(consolidationData.getComputeConsolidationData());
 268     Set<String> serviceTemplateFileNames = consolidationData.getComputeConsolidationData()
 269         .getAllServiceTemplateFileNames();
 270     Assert.assertNotNull(serviceTemplateFileNames);
 271     for(String serviceTemplateName : serviceTemplateFileNames){
 272       Assert.assertTrue(expectedServiceTemplateModels.containsKey(serviceTemplateName));
 273       ServiceTemplate expectedServiceTemplate = expectedServiceTemplateModels.get
 274           (serviceTemplateName);
 275       FileComputeConsolidationData fileComputeConsolidationData = consolidationData
 276           .getComputeConsolidationData().getFileComputeConsolidationData(serviceTemplateName);
 277       Assert.assertNotNull(fileComputeConsolidationData);
 278       Set<String> computeTypes = fileComputeConsolidationData.getAllComputeTypes();
 279       Assert.assertNotNull(computeTypes);
 280       for(String computeType : computeTypes) {
 281         TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData
 282             .getTypeComputeConsolidationData(computeType);
 283         Assert.assertNotNull(typeComputeConsolidationData);
 284
 285         Collection<String> computeNodeTemplateIds = typeComputeConsolidationData
 286             .getAllComputeNodeTemplateIds();
 287         Assert.assertNotNull(computeNodeTemplateIds);
 288         Assert.assertNotEquals(computeNodeTemplateIds.size(), 0);
 289
 290         for(String computeNodeTemplateId : computeNodeTemplateIds) {
 291           ComputeTemplateConsolidationData computeTemplateConsolidationData =
 292               typeComputeConsolidationData.getComputeTemplateConsolidationData
 293                   (computeNodeTemplateId);
 294           switch(validationType){
 295             case VALIDATE_GROUP:
 296               validateGroupsInConsolidationData(computeNodeTemplateId,
 297                   computeTemplateConsolidationData, expectedServiceTemplate);
 298               break;
 299             case VALIDATE_PORT:
 300               validatePortsInConsolidationData(computeNodeTemplateId,
 301                   computeTemplateConsolidationData,
 302                   expectedServiceTemplate);
 303               break;
 304             case VALIDATE_VOLUME:
 305               validateVolumeInConsolidationData(computeNodeTemplateId,
 306                   computeTemplateConsolidationData, expectedServiceTemplate, testName);
 307               break;
 308             case VALIDATE_CONNECTIVITY:
 309               validateComputeConnectivityIn(computeTemplateConsolidationData,
 310                   expectedServiceTemplate);
 311               validateComputeConnectivityOut(computeNodeTemplateId,computeTemplateConsolidationData,
 312                   expectedServiceTemplate);
 313               break;
 314             case VALIDATE_DEPENDS_ON:
 315               validateDependsOnInConsolidationData(computeNodeTemplateId,
 316                   computeTemplateConsolidationData,
 317                   expectedServiceTemplate, testName);
 318               break;
 319           }
 320         }
 321       }
 322     }
 323   }
 324
 325   public void validateGetAttribute(String testName){
 326     Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates
 327         (expectedResultMap);
 328     validateGetAttr(translationContext,expectedServiceTemplateModels,testName);
 329   }
 330
 331   public void validateNestedTemplateConsolidationData(String testName){
 332     validateNestedConsolidationData(translationContext, testName);
 333   }
 334
 335   public void validatePortTemplateConsolidationData(ConsolidationDataValidationType
 336                                                         validationType,
 337                                                     String testName) {
 338     ConsolidationData consolidationData = translationContext.getConsolidationData();
 339     Map<String, ServiceTemplate> expectedServiceTemplateModels = TestUtils.getServiceTemplates
 340         (expectedResultMap);
 341     Assert.assertNotNull(consolidationData);
 342     Assert.assertNotNull(consolidationData.getPortConsolidationData());
 343     Set<String> serviceTemplateFileNames = consolidationData.getPortConsolidationData()
 344         .getAllServiceTemplateFileNames();
 345     Assert.assertNotNull(serviceTemplateFileNames);
 346     for(String serviceTemplateName : serviceTemplateFileNames){
 347       Assert.assertTrue(expectedServiceTemplateModels.containsKey(serviceTemplateName));
 348       ServiceTemplate expectedServiceTemplate = expectedServiceTemplateModels.get
 349           (serviceTemplateName);
 350       FilePortConsolidationData filePortConsolidationData = consolidationData
 351           .getPortConsolidationData().getFilePortConsolidationData(serviceTemplateName);
 352       Assert.assertNotNull(filePortConsolidationData);
 353
 354       Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
 355       Assert.assertNotNull(portNodeTemplateIds);
 356       Assert.assertNotEquals(portNodeTemplateIds.size(), 0);
 357
 358       for(String portNodeTemplateId : portNodeTemplateIds) {
 359         PortTemplateConsolidationData portTemplateConsolidationData =
 360             filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
 361         switch(validationType){
 362           case VALIDATE_CONNECTIVITY:
 363             validatePortConnectivityIn(portTemplateConsolidationData,expectedServiceTemplate);
 364             validatePortConnectivityOut(portNodeTemplateId, portTemplateConsolidationData,
 365                 expectedServiceTemplate);
 366             break;
 367         }
 368       }
 369     }
 370   }
 371 }