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