gerrit.onap Code Review - sdc.git/blob

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