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