test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/artifacts/ValidateArtResponse.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.ci.tests.execute.artifacts;
  22
  23 import java.io.File;
  24 import java.io.IOException;
  25 import java.util.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29
  30 import org.junit.Rule;
  31 import org.junit.rules.TestName;
  32 import org.openecomp.sdc.be.datatypes.elements.HeatParameterDataDefinition;
  33 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  34 import org.openecomp.sdc.be.model.ArtifactDefinition;
  35 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  36 import org.openecomp.sdc.be.model.Resource;
  37 import org.openecomp.sdc.be.model.User;
  38 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  39 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  40 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  41 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  42 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  43 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  44 import org.openecomp.sdc.ci.tests.utils.Decoder;
  45 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  46 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  47 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  48 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  49 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  50 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
  51 import org.testng.AssertJUnit;
  52 import org.testng.annotations.BeforeMethod;
  53 import org.testng.annotations.Test;
  54 import org.yaml.snakeyaml.Yaml;
  55
  56 public class ValidateArtResponse extends ComponentBaseTest {
  57
  58         @Rule
  59         public static TestName name = new TestName();
  60         protected String serviceVersion;
  61
  62         public ValidateArtResponse() {
  63                 super(name, ArtifactServletTest.class.getName());
  64
  65         }
  66
  67         protected final String pathToFile = "heatArtifactParameters";
  68         protected final String heatWithValidParams = "heatWithValidParams.yaml";
  69         protected final String heatWithParamsMissingDefault = "heatWithParamsMissingDefault.yaml";
  70         protected final String heatWithParamsMissingDesc = "heatWithParamsMissingDesc.yaml";
  71         protected final String heatWithParamsMissingType = "heatWithParamsMissingType.yaml";
  72         protected final String importNoDerivedFromFile = "myComputeDerivedFromNotExists.yml";
  73         protected final String decodedPayload = "decodedPayload";
  74         protected final String encodedPayload = "encodedPayload";
  75
  76         protected Resource resourceDetailsObj;
  77         protected ResourceReqDetails resourceDetails;
  78         protected User sdncDesignerDetails;
  79
  80         @BeforeMethod
  81         public void init() throws Exception {
  82
  83                 resourceDetailsObj = AtomicOperationUtils
  84                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
  85                 resourceDetails = new ResourceReqDetails(resourceDetailsObj);
  86                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  87
  88         }
  89
  90         @Test
  91         public void compareParamtersVsYaml() throws Exception {
  92
  93                 // select file to upload
  94
  95                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
  96
  97                 // upload HEAT file and save JSON response
  98
  99                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 100                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 101                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 102
 103                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 104                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 105
 106                 // create MAP from received JSON
 107
 108                 String section2extract = "heatParameters";
 109                 String createKeyMapBy = "name";
 110                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 111                                 section2extract, createKeyMapBy);
 112
 113                 // Prepare map to validate JS
 114
 115                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 116
 117                 // compare MAPs
 118
 119                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 120
 121         }
 122
 123         protected void assertnull(String string, boolean equals) {
 124                 // TODO Auto-generated method stub
 125
 126         }
 127
 128         public Map<String, String> extractSingleParameter(Map<String, String> curr) {
 129                 Map<String, String> innerMap = new HashMap<String, String>();
 130                 if (curr.containsKey("description")) {
 131                         innerMap.put("description", curr.get("description"));
 132                 }
 133
 134                 if (curr.containsKey("defaultValue")) {
 135                         innerMap.put("default", curr.get("defaultValue"));
 136                 } else {
 137                         // System.out.println("kuku");
 138                 }
 139                 innerMap.put("type", curr.get("type"));
 140                 return innerMap;
 141         }
 142
 143         public Map<String, Map> createMapFromYaml(String payload) {
 144                 ArrayList<String> parametersList = new ArrayList<String>();
 145
 146                 Yaml yaml = new Yaml();
 147
 148                 Map<String, Map> result = (Map<String, Map>) yaml.load(payload);
 149                 Map<String, Map> paramters = (Map<String, Map>) result.get("parameters");
 150
 151                 for (Map.Entry<String, Map> entry : paramters.entrySet()) {
 152                         Map<String, String> origInnerMap = (Map<String, String>) entry.getValue();
 153
 154                         if (origInnerMap.containsKey("label")) {
 155                                 origInnerMap.remove("label");
 156                                 paramters.remove(entry);
 157                                 paramters.put(entry.getKey(), origInnerMap);
 158                         }
 159                 }
 160                 return paramters;
 161         }
 162
 163         public Map<String, Map<String, String>> jsonToMap(RestResponse addInformationalArtifactToResource,
 164                         String section2extract, String createKeyMapBy) {
 165                 Map<String, Object> JsonToMap = new HashMap<String, Object>();
 166                 JsonToMap = (Map<String, Object>) ResponseParser.parseToObject(addInformationalArtifactToResource.getResponse(),
 167                                 JsonToMap.getClass());
 168
 169                 List<Map<String, String>> listOfParamters = (List<Map<String, String>>) JsonToMap.get(section2extract);
 170                 Map<String, Map<String, String>> mapOfActualParameters = new HashMap<String, Map<String, String>>();
 171
 172                 for (Map<String, String> curr : listOfParamters) {
 173                         Map<String, String> innerMap = extractSingleParameter(curr);
 174
 175                         mapOfActualParameters.put(curr.get(createKeyMapBy), innerMap);
 176                 }
 177                 return mapOfActualParameters;
 178         }
 179
 180         public Map<String, String> selectFileToUpload(String pathToFile, String fileName) throws IOException {
 181                 String sourceDir = config.getResourceConfigDir();
 182                 String testResourcesPath = sourceDir + File.separator + pathToFile;
 183                 String file = fileName;
 184                 Map<String, String> filePayload = new HashMap<String, String>();
 185                 String payload = Decoder.readFileToString(testResourcesPath + File.separator + file);
 186                 filePayload.put(decodedPayload, payload);
 187                 filePayload.put(encodedPayload, Decoder.encode(payload.getBytes()));
 188
 189                 return filePayload;
 190         }
 191
 192         @Test
 193         public void missingDescParam() throws Exception {
 194
 195                 // select file to upload
 196
 197                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingDesc);
 198
 199                 // upload HEAT file and save JSON response
 200
 201                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 202                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 203                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 204
 205                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 206                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 207
 208                 // create MAP from received JSON
 209
 210                 String section2extract = "heatParameters";
 211                 String createKeyMapBy = "name";
 212                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 213                                 section2extract, createKeyMapBy);
 214
 215                 // Prepare map to validate JS
 216
 217                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 218
 219                 // compare MAPs
 220
 221                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 222
 223         }
 224
 225         @Test
 226         public void missingDefaultParam() throws Exception {
 227
 228                 // select file to upload
 229
 230                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingDefault);
 231
 232                 // upload HEAT file and save JSON response
 233
 234                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 235                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 236                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 237
 238                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 239                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 240
 241                 // create MAP from received JSON
 242
 243                 String section2extract = "heatParameters";
 244                 String createKeyMapBy = "name";
 245                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 246                                 section2extract, createKeyMapBy);
 247
 248                 // Prepare map to validate JS
 249
 250                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 251
 252                 // compare MAPs
 253
 254                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 255
 256         }
 257
 258         @Test
 259         public void missingTypeParam() throws Exception {
 260
 261                 // select file to upload
 262
 263                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingType);
 264
 265                 // upload HEAT file and save JSON response
 266
 267                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 268                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 269                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 270
 271                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 272                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 273
 274                 // System.out.println(addInformationalArtifactToResource);
 275                 AssertJUnit.assertTrue(
 276                                 "response code is not 400, returned :" + addInformationalArtifactToResource.getErrorCode(),
 277                                 addInformationalArtifactToResource.getErrorCode() == 400);
 278
 279         }
 280
 281         @Test
 282         public void updateValueParam() throws Exception {
 283
 284                 String updateValueParam = "changed";
 285
 286                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
 287
 288                 // upload HEAT file and save JSON response
 289
 290                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 291                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 292                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 293
 294                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 295                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 296
 297                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 298                 // System.out.println(resourceGetResponse.getResponse().toString());
 299                 String atifactUniqueId = ResponseParser
 300                                 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
 301
 302                 ArtifactReqDetails artifacJavaObject = ResponseParser
 303                                 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
 304                 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
 305
 306                 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
 307                         heatParameterDefinition.setCurrentValue(updateValueParam);
 308                 }
 309                 artifacJavaObject.setHeatParameters(heatParameters2);
 310                 artifacJavaObject.setPayloadData(null);
 311
 312                 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
 313                                 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
 314
 315                 // verify change in update response
 316
 317                 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
 318                                 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
 319                 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
 320                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 321                         String verify = updateValueParam;
 322                         AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
 323                 }
 324
 325                 // verify change in getResource
 326
 327                 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 328
 329                 Resource resourceRespJavaObject = ResponseParser
 330                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 331                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 332                 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
 333                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 334                         String verify = updateValueParam;
 335                         AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
 336                 }
 337
 338                 // create MAP from received JSON
 339
 340                 String section2extract = "heatParameters";
 341                 String createKeyMapBy = "name";
 342                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 343                                 section2extract, createKeyMapBy);
 344
 345                 // Prepare map to validate JS
 346
 347                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 348
 349                 // compare MAPs
 350
 351                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 352
 353         }
 354
 355         @Test
 356         public void updateValueParamMissingDefault() throws Exception {
 357
 358                 String updateValueParam = "changed";
 359
 360                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingDefault);
 361
 362                 // upload HEAT file and save JSON response
 363
 364                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 365                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 366                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 367
 368                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 369                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 370
 371                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 372                 // System.out.println(resourceGetResponse.getResponse().toString());
 373                 String atifactUniqueId = ResponseParser
 374                                 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
 375
 376                 ArtifactReqDetails artifacJavaObject = ResponseParser
 377                                 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
 378                 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
 379
 380                 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
 381                         heatParameterDefinition.setCurrentValue(updateValueParam);
 382                 }
 383                 artifacJavaObject.setHeatParameters(heatParameters2);
 384                 artifacJavaObject.setPayloadData(null);
 385
 386                 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
 387                                 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
 388
 389                 // verify change in update response
 390
 391                 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
 392                                 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
 393                 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
 394                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 395                         String verify = updateValueParam;
 396                         AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
 397                 }
 398
 399                 // verify change in getResource
 400
 401                 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 402
 403                 Resource resourceRespJavaObject = ResponseParser
 404                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 405                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 406                 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
 407                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 408                         String verify = updateValueParam;
 409                         AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
 410                 }
 411
 412                 // create MAP from received JSON
 413
 414                 String section2extract = "heatParameters";
 415                 String createKeyMapBy = "name";
 416                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 417                                 section2extract, createKeyMapBy);
 418
 419                 // Prepare map to validate JS
 420
 421                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 422
 423                 // compare MAPs
 424
 425                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 426
 427         }
 428
 429         @Test
 430         public void updateValueParamNull() throws Exception {
 431
 432                 String updateValueParam = null;
 433
 434                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
 435
 436                 // upload HEAT file and save JSON response
 437                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 438                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 439                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 440
 441                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 442                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 443
 444                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 445                 // System.out.println(resourceGetResponse.getResponse().toString());
 446                 String atifactUniqueId = ResponseParser
 447                                 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
 448
 449                 ArtifactReqDetails artifacJavaObject = ResponseParser
 450                                 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
 451                 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
 452
 453                 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
 454                         heatParameterDefinition.setCurrentValue(updateValueParam);
 455                 }
 456                 artifacJavaObject.setHeatParameters(heatParameters2);
 457                 artifacJavaObject.setPayloadData(null);
 458
 459                 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
 460                                 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
 461
 462                 // verify change in update response
 463                 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
 464                                 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
 465                 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
 466                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 467                         // String verify = updateValueParam;
 468                         if (heatParameterDefinition.getDefaultValue() != null) {
 469                                 AssertJUnit.assertTrue(
 470                                                 heatParameterDefinition.getDefaultValue().equals(heatParameterDefinition.getCurrentValue()));
 471                         } else {
 472                                 AssertJUnit.assertNull("verification failed", heatParameterDefinition.getCurrentValue());
 473                         }
 474                 }
 475
 476                 // verify change in getResource
 477                 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 478
 479                 Resource resourceRespJavaObject = ResponseParser
 480                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 481                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 482                 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
 483                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 484                         // String verify = updateValueParam;
 485                         if (heatParameterDefinition.getDefaultValue() != null) {
 486                                 AssertJUnit.assertTrue(
 487                                                 heatParameterDefinition.getDefaultValue().equals(heatParameterDefinition.getCurrentValue()));
 488                         } else {
 489                                 AssertJUnit.assertNull("verification failed", heatParameterDefinition.getCurrentValue());
 490                         }
 491                 }
 492
 493                 // create MAP from received JSON
 494                 String section2extract = "heatParameters";
 495                 String createKeyMapBy = "name";
 496                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 497                                 section2extract, createKeyMapBy);
 498
 499                 // Prepare map to validate JS
 500                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 501
 502                 // compare MAPs
 503                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 504
 505         }
 506
 507         @Test
 508         public void updateValueParamEmpty() throws Exception {
 509
 510                 String updateValueParam = "";
 511
 512                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
 513
 514                 // upload HEAT file and save JSON response
 515
 516                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 517                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 518                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 519
 520                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 521                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 522
 523                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 524                 // System.out.println(resourceGetResponse.getResponse().toString());
 525                 String atifactUniqueId = ResponseParser
 526                                 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
 527
 528                 ArtifactReqDetails artifacJavaObject = ResponseParser
 529                                 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
 530                 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
 531
 532                 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
 533                         heatParameterDefinition.setCurrentValue(updateValueParam);
 534                 }
 535                 artifacJavaObject.setHeatParameters(heatParameters2);
 536                 artifacJavaObject.setPayloadData(null);
 537
 538                 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
 539                                 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
 540
 541                 // verify change in update response
 542
 543                 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
 544                                 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
 545                 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
 546                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 547                         String verify = updateValueParam;
 548                         AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
 549                 }
 550
 551                 // verify change in getResource
 552
 553                 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 554
 555                 Resource resourceRespJavaObject = ResponseParser
 556                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 557                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 558                 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
 559                 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
 560                         String verify = updateValueParam;
 561                         AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
 562                 }
 563
 564                 // create MAP from received JSON
 565                 String section2extract = "heatParameters";
 566                 String createKeyMapBy = "name";
 567                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 568                                 section2extract, createKeyMapBy);
 569
 570                 // Prepare map to validate JS
 571                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 572
 573                 // compare MAPs
 574                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 575
 576         }
 577
 578         @Test
 579         public void onlyValueParamPermited() throws Exception {
 580
 581                 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
 582
 583                 // upload HEAT file and save JSON response
 584                 ArtifactReqDetails heatArtifactDetails = ElementFactory
 585                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 586                 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
 587
 588                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
 589                                 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
 590
 591                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 592                 // System.out.println(resourceGetResponse.getResponse().toString());
 593                 String atifactUniqueId = ResponseParser
 594                                 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
 595
 596                 ArtifactReqDetails artifacJavaObject = ResponseParser
 597                                 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
 598                 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
 599
 600                 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
 601                         heatParameterDefinition.setDefaultValue("changed");
 602                         heatParameterDefinition.setName("changed");
 603                         heatParameterDefinition.setDescription("changed");
 604                         heatParameterDefinition.setType("changed");
 605                         heatParameterDefinition.setCurrentValue("changed");
 606                 }
 607                 artifacJavaObject.setHeatParameters(heatParameters2);
 608                 artifacJavaObject.setPayloadData(null);
 609
 610                 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
 611                                 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
 612
 613                 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
 614
 615                 // create MAP from received JSON
 616
 617                 String section2extract = "heatParameters";
 618                 String createKeyMapBy = "name";
 619                 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
 620                                 section2extract, createKeyMapBy);
 621
 622                 // Prepare map to validate JS
 623
 624                 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
 625
 626                 // compare MAPs
 627
 628                 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
 629
 630         }
 631
 632 }