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