openecomp-be/lib/openecomp-sdc-validation-lib/openecomp-sdc-validation-sdk/src/main/java/org/openecomp/sdc/validation/util/ValidationTestUtil.java

   1 package org.openecomp.sdc.validation.util;
   2
   3 import org.apache.commons.collections4.MapUtils;
   4 import org.apache.commons.io.IOUtils;
   5 import org.openecomp.core.utilities.CommonMethods;
   6 import org.openecomp.core.utilities.file.FileUtils;
   7 import org.openecomp.core.utilities.json.JsonUtil;
   8 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
   9 import org.openecomp.core.validation.types.GlobalValidationContext;
  10 import org.openecomp.core.validation.types.MessageContainer;
  11 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  12 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  13 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  14 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  15 import org.openecomp.sdc.heat.datatypes.model.Resource;
  16 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  17 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
  18 import org.openecomp.sdc.validation.ResourceValidator;
  19 import org.openecomp.sdc.validation.ValidationContext;
  20 import org.openecomp.sdc.validation.Validator;
  21 import org.openecomp.sdc.validation.base.ResourceBaseValidator;
  22 import org.testng.Assert;
  23
  24 import java.io.File;
  25 import java.io.FileInputStream;
  26 import java.io.IOException;
  27 import java.io.StringWriter;
  28 import java.net.URL;
  29 import java.util.Collection;
  30 import java.util.HashMap;
  31 import java.util.Map;
  32 import java.util.Objects;
  33
  34 /**
  35  * Created by TALIO on 2/26/2017.
  36  */
  37 public class ValidationTestUtil {
  38
  39   public static GlobalValidationContext createGlobalContextFromPath(String path) {
  40     GlobalValidationContext globalValidationContext = new GlobalValidationContext();
  41     Map<String, byte[]> contentMap = getContentMapByPath(path);
  42     if (contentMap == null) {
  43       return null;
  44     }
  45     contentMap.entrySet()
  46         .forEach(entry -> globalValidationContext.addFileContext(entry.getKey(), entry.getValue()));
  47
  48     return globalValidationContext;
  49   }
  50
  51   private static Map<String, byte[]> getContentMapByPath(String path) {
  52     Map<String, byte[]> contentMap = new HashMap<>();
  53     byte[] fileContent;
  54     FileInputStream fis;
  55     URL url = ValidationTestUtil.class.getResource(path);
  56     File pathFile = new File(url.getFile());
  57     File[] files;
  58     if (pathFile.isDirectory()) {
  59       files = pathFile.listFiles();
  60     } else {
  61       files = new File[]{pathFile};
  62     }
  63
  64     if (files == null || files.length == 0) {
  65       return null;
  66     }
  67
  68     for (File file : files) {
  69       try {
  70         fis = new FileInputStream(file);
  71         fileContent = FileUtils.toByteArray(fis);
  72         contentMap.put(file.getName(), fileContent);
  73       } catch (IOException e) {
  74         e.printStackTrace();
  75       }
  76     }
  77     return contentMap;
  78   }
  79
  80   public static Map<String, MessageContainer> testValidator(Validator validator, String path) {
  81
  82     GlobalValidationContext globalValidationContext = createGlobalContextFromPath(path);
  83     validator.validate(globalValidationContext);
  84
  85     assert globalValidationContext != null;
  86     return globalValidationContext.getContextMessageContainers();
  87
  88
  89   }
  90
  91   public static Map<String, MessageContainer> testValidator(ResourceBaseValidator baseValidator,
  92                                                             ResourceValidator resourceValidator,
  93                                                             String resourceTypeToValidate, String path) {
  94
  95     GlobalValidationContext globalContext = createGlobalContextFromPath(path);
  96     ManifestContent manifestContent = ValidationUtil.checkValidationPreCondition(globalContext);
  97     Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
  98     Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
  99
 100     validateFiles(baseValidator, resourceValidator, globalContext, fileEnvMap, fileTypeMap,
 101         resourceTypeToValidate);
 102
 103     assert globalContext != null;
 104     return globalContext.getContextMessageContainers();
 105
 106
 107   }
 108
 109   private static void validateFiles(ResourceBaseValidator baseValidator,
 110                                     ResourceValidator resourceValidator,
 111                                     GlobalValidationContext globalContext,
 112                                     Map<String, FileData> fileEnvMap,
 113                                     Map<String, FileData.Type> fileTypeMap,
 114                                     String resourceTypeToValidate) {
 115
 116     Collection<String> files = globalContext.getFiles();
 117     for(String fileName : files){
 118       if(FileData.isHeatFile(fileTypeMap.get(fileName))) {
 119         HeatOrchestrationTemplate heatOrchestrationTemplate =
 120             ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalContext);
 121
 122         if (Objects.isNull(heatOrchestrationTemplate)) {
 123           continue;
 124         }
 125
 126         ValidationContext validationContext = baseValidator.createValidationContext
 127             (fileName,
 128                 fileEnvMap.get(fileName) == null ? null : fileEnvMap.get(fileName).getFile(),
 129                 heatOrchestrationTemplate, globalContext);
 130
 131         validateResources(fileName, resourceValidator, resourceTypeToValidate, validationContext,
 132             globalContext);
 133       }
 134     }
 135   }
 136
 137   public static void validateResources(String fileName,
 138                                        ResourceValidator resourceValidator,
 139                                        String resourceTypeToValidate,
 140                                        ValidationContext validationContext,
 141                                        GlobalValidationContext globalValidationContext){
 142
 143     HeatOrchestrationTemplate heatOrchestrationTemplate =
 144         ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalValidationContext);
 145     Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
 146
 147     if(MapUtils.isEmpty(resourcesMap)){
 148       return;
 149     }
 150
 151     resourcesMap.entrySet()
 152         .stream()
 153         .filter(resourceEntry -> isResourceNeedToBeTested(resourceEntry.getValue().getType(), resourceTypeToValidate))
 154         .forEach(resourceEntry ->
 155             resourceValidator.validate
 156                 (fileName, resourceEntry, globalValidationContext, validationContext));
 157   }
 158
 159   private static boolean isResourceNeedToBeTested(String currResource, String resourceToTest){
 160     if(Objects.isNull(resourceToTest)){
 161       return HeatStructureUtil.isNestedResource(currResource);
 162     }
 163
 164     return currResource.equals(resourceToTest);
 165   }
 166
 167   public static void validateErrorMessage(String actualMessage, String expected, String... params) {
 168     Assert.assertEquals(actualMessage.replace("\n", "").replace("\r", ""),
 169         ErrorMessagesFormatBuilder.getErrorWithParameters(expected, params).replace("\n", "")
 170             .replace("\r", ""));
 171
 172   }
 173
 174   public static Validator cerateValidatorImpl(ImplementationConfiguration validatorConf) {
 175     Validator validator = null;
 176     try {
 177       validator =
 178           CommonMethods.newInstance(validatorConf.getImplementationClass(), Validator.class);
 179       validator.init(validatorConf.getProperties());
 180     } catch (IllegalArgumentException iae) {
 181       return null;
 182     }
 183     return validator;
 184   }
 185
 186   public static Map<String, Object> getResourceMap(String configFileName) throws IOException {
 187     URL mockResource = ValidationTestUtil.class.getResource(configFileName);
 188     StringWriter writer = new StringWriter();
 189     String json = IOUtils.toString(mockResource.openStream(), "UTF-8");
 190     return JsonUtil.json2Object(json, Map.class);
 191   }
 192 }