openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/BaseResourceTranslationTest.java

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