gerrit.onap Code Review - sdc.git/blob

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