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