catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import fj.data.Either;
  24 import org.junit.Test;
  25 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  26 import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum;
  27 import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaTagNamesEnum;
  28 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  29 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  30 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  31 import org.openecomp.sdc.be.model.PropertyDefinition;
  32 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  33 import org.yaml.snakeyaml.Yaml;
  34
  35 import java.io.IOException;
  36 import java.nio.file.FileSystems;
  37 import java.nio.file.Files;
  38 import java.util.ArrayList;
  39 import java.util.HashMap;
  40 import java.util.Iterator;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.Map.Entry;
  44
  45 import static org.junit.Assert.assertEquals;
  46 import static org.junit.Assert.assertFalse;
  47 import static org.junit.Assert.assertNotNull;
  48 import static org.junit.Assert.assertTrue;
  49
  50 public class ImportUtilsTest {
  51     @Test
  52     public void testStringTypeFindToscaElements() throws IOException {
  53         Either<List<Object>, ResultStatusEnum> toscaElements = ImportUtils.findToscaElements((Map<String, Object>) loadJsonFromFile("normative-types-string-list-test.yml"), "stringTestTag", ToscaElementTypeEnum.STRING, new ArrayList<>());
  54         assertTrue(toscaElements.isLeft());
  55         List<Object> list = toscaElements.left().value();
  56         assertTrue(list.size() == 4);
  57         int count = 1;
  58         for (Object element : list) {
  59             assertTrue(element instanceof String);
  60             String value = (String) element;
  61             assertTrue(value.equals("stringVal" + count));
  62             count++;
  63         }
  64     }
  65
  66     @Test
  67     public void testBooleanTypeFindToscaElements() throws IOException {
  68         Either<List<Object>, ResultStatusEnum> toscaElements = ImportUtils.findToscaElements((Map<String, Object>) loadJsonFromFile("normative-types-all-map-test.yml"), "required", ToscaElementTypeEnum.BOOLEAN, new ArrayList<>());
  69         assertTrue(toscaElements.isLeft());
  70         List<Object> list = toscaElements.left().value();
  71         assertTrue(list.size() == 3);
  72         int count = 1;
  73         for (Object element : list) {
  74             assertTrue(element instanceof Boolean);
  75             Boolean value = (Boolean) element;
  76             if (count == 1 || count == 3) {
  77                 assertFalse(value);
  78             } else if (count == 2) {
  79                 assertTrue(value);
  80             }
  81
  82             count++;
  83         }
  84     }
  85
  86     @Test
  87     public void testListTypeFindToscaElements() throws IOException {
  88         Either<List<Object>, ResultStatusEnum> toscaElements = ImportUtils.findToscaElements((Map<String, Object>) loadJsonFromFile("normative-types-string-list-test.yml"), "listTestTag", ToscaElementTypeEnum.LIST, new ArrayList<>());
  89         assertTrue(toscaElements.isLeft());
  90         List<Object> list = toscaElements.left().value();
  91         assertTrue(list.size() == 3);
  92         int count = 1;
  93         for (Object element : list) {
  94             assertTrue(element instanceof List);
  95
  96             if (count == 1) {
  97                 verifyListElement1(element);
  98             } else if (count == 2) {
  99                 verifyListElement2(element);
 100             }
 101
 102             else if (count == 3) {
 103                 verifyListElement3(element);
 104             }
 105             count++;
 106         }
 107     }
 108
 109     @Test
 110     public void testAllTypeFindToscaElements() throws IOException {
 111         Either<List<Object>, ResultStatusEnum> toscaElements = ImportUtils.findToscaElements((Map<String, Object>) loadJsonFromFile("normative-types-all-map-test.yml"), "allTestTag", ToscaElementTypeEnum.ALL, new ArrayList<>());
 112         assertTrue(toscaElements.isLeft());
 113         List<Object> list = toscaElements.left().value();
 114         assertTrue(list.size() == 5);
 115         int count = 1;
 116         for (Object element : list) {
 117             if (count == 1) {
 118                 assertTrue(element instanceof String);
 119                 assertTrue(element.equals("tosca.nodes.Root"));
 120             } else if (count == 2) {
 121                 assertTrue(element instanceof Map);
 122                 Map<String, Object> mapElement = (Map<String, Object>) element;
 123                 assertTrue(mapElement.size() == 2);
 124                 Iterator<Entry<String, Object>> elementEntries = mapElement.entrySet().iterator();
 125                 Entry<String, Object> elementEntry = elementEntries.next();
 126                 assertTrue(elementEntry.getKey().equals("mapTestTag"));
 127                 assertTrue(elementEntry.getValue().equals("string"));
 128
 129                 elementEntry = elementEntries.next();
 130                 assertTrue(elementEntry.getKey().equals("required"));
 131                 assertTrue(elementEntry.getValue() instanceof Boolean);
 132                 assertTrue((Boolean) elementEntry.getValue());
 133             }
 134
 135             else if (count == 3) {
 136                 assertTrue(element instanceof String);
 137                 assertTrue(element.equals("1 MB"));
 138             }
 139
 140             else if (count == 4) {
 141                 assertTrue(element instanceof List);
 142                 List<Object> listElement = (List<Object>) element;
 143                 assertTrue(listElement.size() == 2);
 144
 145                 assertTrue(listElement.get(0) instanceof Map);
 146                 Map<String, Object> innerElement = (Map<String, Object>) listElement.get(0);
 147                 assertTrue(innerElement.size() == 1);
 148                 Entry<String, Object> innerEntry = innerElement.entrySet().iterator().next();
 149                 assertTrue(innerEntry.getKey().equals("greater_or_equal"));
 150                 assertTrue(innerEntry.getValue().equals("1 MB"));
 151
 152                 assertTrue(listElement.get(1) instanceof Map);
 153                 innerElement = (Map<String, Object>) listElement.get(1);
 154                 assertTrue(innerElement.size() == 1);
 155                 innerEntry = innerElement.entrySet().iterator().next();
 156                 assertTrue(innerEntry.getKey().equals("stringTestTag"));
 157                 assertTrue(innerEntry.getValue().equals("stringVal3"));
 158             } else if (count == 5) {
 159                 assertTrue(element instanceof Boolean);
 160                 assertFalse((Boolean) element);
 161             }
 162             count++;
 163         }
 164     }
 165
 166     @Test
 167     public void testMapTypeFindToscaElements() throws IOException {
 168         Either<List<Object>, ResultStatusEnum> toscaElements = ImportUtils.findToscaElements((Map<String, Object>) loadJsonFromFile("normative-types-all-map-test.yml"), "mapTestTag", ToscaElementTypeEnum.MAP, new ArrayList<>());
 169         assertTrue(toscaElements.isLeft());
 170         List<Object> list = toscaElements.left().value();
 171         assertTrue(list.size() == 2);
 172         int count = 1;
 173         for (Object element : list) {
 174             assertTrue(element instanceof Map);
 175
 176             if (count == 1) {
 177                 Map<String, Object> mapElement = (Map<String, Object>) element;
 178                 assertTrue(mapElement.size() == 2);
 179                 Iterator<Entry<String, Object>> iterator = mapElement.entrySet().iterator();
 180                 Entry<String, Object> inerElementEntry = iterator.next();
 181                 assertTrue(inerElementEntry.getKey().equals("stringTestTag"));
 182                 assertTrue(inerElementEntry.getValue().equals("stringVal1"));
 183
 184                 inerElementEntry = iterator.next();
 185                 assertTrue(inerElementEntry.getKey().equals("listTestTag"));
 186                 assertTrue(inerElementEntry.getValue() instanceof List);
 187                 List<Object> innerValue = (List<Object>) inerElementEntry.getValue();
 188
 189                 assertTrue(innerValue.size() == 3);
 190
 191             } else if (count == 2) {
 192                 Map<String, Object> mapElement = (Map<String, Object>) element;
 193                 assertTrue(mapElement.size() == 2);
 194                 Iterator<Entry<String, Object>> entryItr = mapElement.entrySet().iterator();
 195                 Entry<String, Object> inerElementEntry = entryItr.next();
 196                 assertTrue(inerElementEntry.getKey().equals("type"));
 197                 assertTrue(inerElementEntry.getValue().equals("tosca.capabilities.Attachment"));
 198                 inerElementEntry = entryItr.next();
 199                 assertTrue(inerElementEntry.getKey().equals("allTestTag"));
 200                 assertTrue(inerElementEntry.getValue() instanceof Boolean);
 201             }
 202
 203             count++;
 204         }
 205     }
 206
 207     @Test
 208     public void testCreateFullHeatParameterModuleWithString() {
 209
 210         testCreateFullHeatParameterModule("string", "default value");
 211
 212     }
 213
 214     @Test
 215     public void testCreateFullHeatParameterModuleWithNumber() {
 216
 217         testCreateFullHeatParameterModule("number", "777");
 218         testCreateFullHeatParameterModule("number", "777.23");
 219
 220     }
 221
 222     @Test
 223     public void testCreateFullHeatParameterModuleWithBoolean() {
 224
 225         testCreateFullHeatParameterModule("boolean", "true");
 226         testCreateFullHeatParameterModule("boolean", "on");
 227         testCreateFullHeatParameterModule("boolean", "n");
 228
 229     }
 230
 231     @Test
 232     public void testCreateFullHeatParameterModuleWithList() {
 233
 234         testCreateFullHeatParameterModule("comma_delimited_list", "[one, two]");
 235
 236     }
 237
 238     // @Test
 239     // public void testCreateFullHeatParameterModuleWithInvalidType(){
 240     //
 241     // String name = "fullParameter";
 242     // String description = "description_text";
 243     //
 244     // Map<String, Object> parametersMap = new HashMap<String, Object>();
 245     // Map<String, Object> firstParam = createParameterMap("aaa", "aaa",
 246     // name, description);
 247     // parametersMap.put(ToscaTagNamesEnum.PARAMETERS.getElementName(),
 248     // firstParam);
 249     //
 250     // Either<List<HeatParameterDefinition>,ResultStatusEnum> heatParameters =
 251     // ImportUtils.getHeatParameters(parametersMap);
 252     // assertTrue(heatParameters.isRight());
 253     // assertEquals(ResultStatusEnum.INVALID_PROPERTY_TYPE,
 254     // heatParameters.right().value());
 255     //
 256     // }
 257
 258     @Test
 259     public void testCreateFullHeatParameterModuleWithMissingType() {
 260
 261         String name = "fullParameter";
 262         String description = "description_text";
 263
 264         Map<String, Object> parametersMap = new HashMap<String, Object>();
 265         Map<String, Object> firstParam = createParameterMap(null, "aaa", name, description);
 266         parametersMap.put(ToscaTagNamesEnum.PARAMETERS.getElementName(), firstParam);
 267
 268         Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils.getHeatParameters(parametersMap, ArtifactTypeEnum.HEAT.getType());
 269         assertTrue(heatParameters.isRight());
 270         assertEquals(ResultStatusEnum.INVALID_PROPERTY_TYPE, heatParameters.right().value());
 271
 272     }
 273
 274     @Test
 275     public void testCreateFullHeatParameterModuleWithMissingFields() {
 276
 277         String name = "fullParameter";
 278
 279         Map<String, Object> parametersMap = new HashMap<String, Object>();
 280         String type = "number";
 281         String defValue = "defvalue";
 282         // default value cannot be empty in heat in case tag exists
 283         Map<String, Object> firstParam = createParameterMap(type, defValue, name, null);
 284         parametersMap.put(ToscaTagNamesEnum.PARAMETERS.getElementName(), firstParam);
 285
 286         Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils.getHeatParameters(parametersMap, ArtifactTypeEnum.HEAT.getType());
 287         assertTrue(heatParameters.isLeft());
 288         List<HeatParameterDefinition> parameterDefList = heatParameters.left().value();
 289         assertFalse(parameterDefList.isEmpty());
 290         HeatParameterDefinition parameterDefinition = parameterDefList.get(0);
 291
 292         assertParameter(parameterDefinition, name, type, null, defValue);
 293
 294     }
 295
 296     @Test
 297     public void testGetAttributesFromYml() throws IOException {
 298
 299         Map<String, Object> toscaJson = (Map<String, Object>) loadJsonFromFile("importToscaWithAttribute.yml");
 300         Either<Map<String, PropertyDefinition>, ResultStatusEnum> actualAttributes = ImportUtils.getAttributes(toscaJson);
 301         assertTrue(actualAttributes.isLeft());
 302         Map<String, Map<String, Object>> expectedAttributes = getElements(toscaJson, ToscaTagNamesEnum.ATTRIBUTES);
 303         compareAttributes(expectedAttributes, actualAttributes.left().value());
 304
 305     }
 306
 307     @Test
 308     public void testGetPropertiesFromYml() throws IOException {
 309
 310         Map<String, Object> toscaJson = (Map<String, Object>) loadJsonFromFile("importToscaProperties.yml");
 311         Either<Map<String, PropertyDefinition>, ResultStatusEnum> actualProperties = ImportUtils.getProperties(toscaJson);
 312         assertTrue(actualProperties.isLeft());
 313         Map<String, Map<String, Object>> expectedProperties = getElements(toscaJson, ToscaTagNamesEnum.PROPERTIES);
 314         compareProperties(expectedProperties, actualProperties.left().value());
 315
 316     }
 317
 318     private void compareAttributes(Map<String, Map<String, Object>> expected, Map<String, PropertyDefinition> actual) {
 319
 320         Map<String, Object> singleExpectedAttribute;
 321         PropertyDefinition actualAttribute, expectedAttributeModel;
 322         // attributes of resource
 323         for (Map.Entry<String, Map<String, Object>> expectedAttribute : expected.entrySet()) {
 324
 325             singleExpectedAttribute = expectedAttribute.getValue();
 326             assertNotNull(singleExpectedAttribute);
 327             actualAttribute = actual.get(expectedAttribute.getKey());
 328             assertNotNull(actualAttribute);
 329             actualAttribute.setName(expectedAttribute.getKey().toString());
 330             expectedAttributeModel = ImportUtils.createModuleAttribute(singleExpectedAttribute);
 331             expectedAttributeModel.setName(expectedAttribute.getKey().toString());
 332
 333             assertEquals(expectedAttributeModel.getDefaultValue(), actualAttribute.getDefaultValue());
 334             assertEquals(expectedAttributeModel.getDescription(), actualAttribute.getDescription());
 335             assertEquals(expectedAttributeModel.getName(), actualAttribute.getName());
 336             assertEquals(expectedAttributeModel.getStatus(), actualAttribute.getStatus());
 337             assertEquals(expectedAttributeModel.getType(), actualAttribute.getType());
 338
 339             compareSchemas(expectedAttributeModel.getSchema(), actualAttribute.getSchema());
 340
 341         }
 342
 343     }
 344
 345     private void compareProperties(Map<String, Map<String, Object>> expected, Map<String, PropertyDefinition> actual) {
 346
 347         Map<String, Object> singleExpectedProperty;
 348         PropertyDefinition actualProperty, expectedPropertyModel;
 349         // attributes of resource
 350         for (Map.Entry<String, Map<String, Object>> expectedProperty : expected.entrySet()) {
 351
 352             singleExpectedProperty = expectedProperty.getValue();
 353             assertNotNull(singleExpectedProperty);
 354             actualProperty = actual.get(expectedProperty.getKey());
 355             assertNotNull(actualProperty);
 356             actualProperty.setName(expectedProperty.getKey().toString());
 357             expectedPropertyModel = ImportUtils.createModuleProperty(singleExpectedProperty);
 358             expectedPropertyModel.setName(expectedProperty.getKey().toString());
 359
 360             assertEquals(expectedPropertyModel.getDefaultValue(), actualProperty.getDefaultValue());
 361             assertEquals(expectedPropertyModel.getDescription(), actualProperty.getDescription());
 362             assertEquals(expectedPropertyModel.getName(), actualProperty.getName());
 363             assertEquals(expectedPropertyModel.getStatus(), actualProperty.getStatus());
 364             assertEquals(expectedPropertyModel.getType(), actualProperty.getType());
 365
 366             compareSchemas(expectedPropertyModel.getSchema(), actualProperty.getSchema());
 367
 368         }
 369
 370     }
 371
 372     private void compareSchemas(SchemaDefinition expected, SchemaDefinition actual) {
 373
 374         if (expected == null && actual == null) {
 375             return;
 376         }
 377         PropertyDataDefinition actualPropertySchema = actual.getProperty();
 378         PropertyDataDefinition expectedPropertySchema = expected.getProperty();
 379         assertNotNull(actualPropertySchema);
 380         assertNotNull(expectedPropertySchema);
 381         assertEquals(expectedPropertySchema.getDescription(), actualPropertySchema.getDescription());
 382         assertEquals(expectedPropertySchema.getType(), actualPropertySchema.getType());
 383
 384     }
 385
 386     private <T> Map<String, T> getElements(Map<String, Object> toscaJson, ToscaTagNamesEnum elementType) {
 387
 388         Either<Map<String, T>, ResultStatusEnum> toscaExpectedElements = ImportUtils.findFirstToscaMapElement(toscaJson, elementType);
 389         assertTrue(toscaExpectedElements.isLeft());
 390
 391         return toscaExpectedElements.left().value();
 392
 393     }
 394
 395     private void testCreateFullHeatParameterModule(String type, Object defaultVal) {
 396
 397         String name = "fullParameter";
 398         String description = "description_text";
 399
 400         Map<String, Object> parametersMap = new HashMap<String, Object>();
 401         Map<String, Object> firstParam = createParameterMap(type, defaultVal, name, description);
 402         parametersMap.put(ToscaTagNamesEnum.PARAMETERS.getElementName(), firstParam);
 403
 404         Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils.getHeatParameters(parametersMap, ArtifactTypeEnum.HEAT.getType());
 405         assertTrue(heatParameters.isLeft());
 406         List<HeatParameterDefinition> parameterDefList = heatParameters.left().value();
 407         assertFalse(parameterDefList.isEmpty());
 408         HeatParameterDefinition parameterDefinition = parameterDefList.get(0);
 409
 410         assertParameter(parameterDefinition, name, type, description, defaultVal);
 411
 412     }
 413
 414     private Map<String, Object> createParameterMap(String type, Object defaultVal, String name, String description) {
 415         Map<String, Object> firstParam = new HashMap<String, Object>();
 416         Map<String, Object> valuesMap = new HashMap<String, Object>();
 417
 418         valuesMap.put(ToscaTagNamesEnum.TYPE.getElementName(), type);
 419         valuesMap.put(ToscaTagNamesEnum.DESCRIPTION.getElementName(), description);
 420         valuesMap.put(ToscaTagNamesEnum.DEFAULT_VALUE.getElementName(), defaultVal);
 421
 422         firstParam.put(name, valuesMap);
 423         return firstParam;
 424     }
 425
 426     private void assertParameter(HeatParameterDefinition parameterDefinition, String name, String type, String description, Object defaultVal) {
 427         assertEquals(name, parameterDefinition.getName());
 428         assertEquals(description, parameterDefinition.getDescription());
 429         assertEquals(type, parameterDefinition.getType());
 430         assertEquals(String.valueOf(defaultVal), parameterDefinition.getDefaultValue());
 431         assertEquals(String.valueOf(defaultVal), parameterDefinition.getCurrentValue());
 432     }
 433
 434     private void verifyListElement3(Object element) {
 435         List<Object> listElement = (List<Object>) element;
 436         assertTrue(listElement.size() == 2);
 437
 438         Map<String, String> innerElement = (Map<String, String>) listElement.get(0);
 439         assertTrue(innerElement.size() == 1);
 440         Entry<String, String> innerEntry = innerElement.entrySet().iterator().next();
 441         assertTrue(innerEntry.getKey().equals("testTag1"));
 442         assertTrue(innerEntry.getValue().equals("1 MB"));
 443
 444         innerElement = (Map<String, String>) listElement.get(1);
 445         assertTrue(innerElement.size() == 1);
 446         innerEntry = innerElement.entrySet().iterator().next();
 447         assertTrue(innerEntry.getKey().equals("type"));
 448         assertTrue(innerEntry.getValue().equals("stringVal2"));
 449     }
 450
 451     private void verifyListElement2(Object element) {
 452         List<Object> listElement = (List<Object>) element;
 453         assertTrue(listElement.size() == 2);
 454
 455         Map<String, Object> innerElement = (Map<String, Object>) listElement.get(0);
 456         assertTrue(innerElement.size() == 1);
 457         Entry<String, Object> innerEntry = innerElement.entrySet().iterator().next();
 458         assertTrue(innerEntry.getKey().equals("testTag1"));
 459         assertTrue(innerEntry.getValue().equals("1 MB"));
 460
 461         assertTrue(listElement.get(1) instanceof Map);
 462         innerElement = (Map<String, Object>) listElement.get(1);
 463         assertTrue(innerElement.size() == 1);
 464         innerEntry = innerElement.entrySet().iterator().next();
 465         assertTrue(innerEntry.getKey().equals("listTestTag"));
 466         assertTrue(innerEntry.getValue() instanceof List);
 467     }
 468
 469     private void verifyListElement1(Object element) {
 470         List<Object> listElement = (List<Object>) element;
 471         assertTrue(listElement.size() == 3);
 472
 473         Map<String, String> innerElement = (Map<String, String>) listElement.get(0);
 474         assertTrue(innerElement.size() == 1);
 475         Entry<String, String> innerEntry = innerElement.entrySet().iterator().next();
 476         assertTrue(innerEntry.getKey().equals("listTestTag"));
 477         assertTrue(innerEntry.getValue().equals("1 MB"));
 478
 479         innerElement = (Map<String, String>) listElement.get(1);
 480         assertTrue(innerElement.size() == 1);
 481         innerEntry = innerElement.entrySet().iterator().next();
 482         assertTrue(innerEntry.getKey().equals("listTestTag"));
 483         assertTrue(innerEntry.getValue().equals("2 MB"));
 484
 485         innerElement = (Map<String, String>) listElement.get(2);
 486         assertTrue(innerElement.size() == 1);
 487         innerEntry = innerElement.entrySet().iterator().next();
 488         assertTrue(innerEntry.getKey().equals("stringTestTag"));
 489         assertTrue(innerEntry.getValue().equals("stringVal2"));
 490     }
 491
 492     public static String loadFileNameToJsonString(String fileName) throws IOException {
 493         String sourceDir = "src/test/resources/normativeTypes";
 494         java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
 495         byte[] fileContent = Files.readAllBytes(filePath);
 496         String content = new String(fileContent);
 497         return content;
 498     }
 499
 500     private static Object loadJsonFromFile(String fileName) throws IOException {
 501         String content = loadFileNameToJsonString(fileName);
 502         Object load = new Yaml().load(content);
 503         return load;
 504     }
 505
 506 }