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