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