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