2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.execute.artifacts;
23 import org.junit.Rule;
24 import org.junit.rules.TestName;
25 import org.openecomp.sdc.be.datatypes.elements.HeatParameterDataDefinition;
26 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
27 import org.openecomp.sdc.be.model.ArtifactDefinition;
28 import org.openecomp.sdc.be.model.HeatParameterDefinition;
29 import org.openecomp.sdc.be.model.Resource;
30 import org.openecomp.sdc.be.model.User;
31 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
32 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
33 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
34 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
35 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
36 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
37 import org.openecomp.sdc.ci.tests.utils.Decoder;
38 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
39 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
40 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
41 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
42 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
43 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
44 import org.testng.AssertJUnit;
45 import org.testng.annotations.BeforeMethod;
46 import org.testng.annotations.Test;
47 import org.yaml.snakeyaml.Yaml;
50 import java.io.IOException;
51 import java.util.ArrayList;
52 import java.util.HashMap;
53 import java.util.List;
56 public class ValidateArtResponse extends ComponentBaseTest {
59 public static TestName name = new TestName();
60 protected String serviceVersion;
62 public ValidateArtResponse() {
63 super(name, ArtifactServletTest.class.getName());
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";
76 protected Resource resourceDetailsObj;
77 protected ResourceReqDetails resourceDetails;
78 protected User sdncDesignerDetails;
81 public void init() throws Exception {
83 resourceDetailsObj = AtomicOperationUtils
84 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
85 resourceDetails = new ResourceReqDetails(resourceDetailsObj);
86 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
91 public void compareParamtersVsYaml() throws Exception {
93 // select file to upload
95 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
97 // upload HEAT file and save JSON response
99 ArtifactReqDetails heatArtifactDetails = ElementFactory
100 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
101 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
103 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
104 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
106 // create MAP from received JSON
108 String section2extract = "heatParameters";
109 String createKeyMapBy = "name";
110 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
111 section2extract, createKeyMapBy);
113 // Prepare map to validate JS
115 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
119 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
123 protected void assertnull(String string, boolean equals) {
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"));
133 if (curr.containsKey("defaultValue")) {
134 innerMap.put("default", curr.get("defaultValue"));
136 // System.out.println("kuku");
138 innerMap.put("type", curr.get("type"));
142 public Map<String, Map> createMapFromYaml(String payload) {
143 ArrayList<String> parametersList = new ArrayList<String>();
145 Yaml yaml = new Yaml();
147 Map<String, Map> result = (Map<String, Map>) yaml.load(payload);
148 Map<String, Map> paramters = (Map<String, Map>) result.get("parameters");
150 for (Map.Entry<String, Map> entry : paramters.entrySet()) {
151 Map<String, String> origInnerMap = (Map<String, String>) entry.getValue();
153 if (origInnerMap.containsKey("label")) {
154 origInnerMap.remove("label");
155 paramters.remove(entry);
156 paramters.put(entry.getKey(), origInnerMap);
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());
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>>();
171 for (Map<String, String> curr : listOfParamters) {
172 Map<String, String> innerMap = extractSingleParameter(curr);
174 mapOfActualParameters.put(curr.get(createKeyMapBy), innerMap);
176 return mapOfActualParameters;
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()));
192 public void missingDescParam() throws Exception {
194 // select file to upload
196 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingDesc);
198 // upload HEAT file and save JSON response
200 ArtifactReqDetails heatArtifactDetails = ElementFactory
201 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
202 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
204 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
205 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
207 // create MAP from received JSON
209 String section2extract = "heatParameters";
210 String createKeyMapBy = "name";
211 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
212 section2extract, createKeyMapBy);
214 // Prepare map to validate JS
216 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
220 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
225 public void missingDefaultParam() throws Exception {
227 // select file to upload
229 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingDefault);
231 // upload HEAT file and save JSON response
233 ArtifactReqDetails heatArtifactDetails = ElementFactory
234 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
235 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
237 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
238 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
240 // create MAP from received JSON
242 String section2extract = "heatParameters";
243 String createKeyMapBy = "name";
244 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
245 section2extract, createKeyMapBy);
247 // Prepare map to validate JS
249 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
253 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
258 public void missingTypeParam() throws Exception {
260 // select file to upload
262 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingType);
264 // upload HEAT file and save JSON response
266 ArtifactReqDetails heatArtifactDetails = ElementFactory
267 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
268 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
270 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
271 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
273 // System.out.println(addInformationalArtifactToResource);
274 AssertJUnit.assertTrue(
275 "response code is not 400, returned :" + addInformationalArtifactToResource.getErrorCode(),
276 addInformationalArtifactToResource.getErrorCode() == 400);
281 public void updateValueParam() throws Exception {
283 String updateValueParam = "changed";
285 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
287 // upload HEAT file and save JSON response
289 ArtifactReqDetails heatArtifactDetails = ElementFactory
290 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
291 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
293 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
294 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
296 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
297 // System.out.println(resourceGetResponse.getResponse().toString());
298 String atifactUniqueId = ResponseParser
299 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
301 ArtifactReqDetails artifacJavaObject = ResponseParser
302 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
303 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
305 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
306 heatParameterDefinition.setCurrentValue(updateValueParam);
308 artifacJavaObject.setHeatParameters(heatParameters2);
309 artifacJavaObject.setPayloadData(null);
311 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
312 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
314 // verify change in update response
316 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
317 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
318 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
319 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
320 String verify = updateValueParam;
321 AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
324 // verify change in getResource
326 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
328 Resource resourceRespJavaObject = ResponseParser
329 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
330 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
331 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
332 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
333 String verify = updateValueParam;
334 AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
337 // create MAP from received JSON
339 String section2extract = "heatParameters";
340 String createKeyMapBy = "name";
341 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
342 section2extract, createKeyMapBy);
344 // Prepare map to validate JS
346 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
350 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
355 public void updateValueParamMissingDefault() throws Exception {
357 String updateValueParam = "changed";
359 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithParamsMissingDefault);
361 // upload HEAT file and save JSON response
363 ArtifactReqDetails heatArtifactDetails = ElementFactory
364 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
365 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
367 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
368 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
370 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
371 // System.out.println(resourceGetResponse.getResponse().toString());
372 String atifactUniqueId = ResponseParser
373 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
375 ArtifactReqDetails artifacJavaObject = ResponseParser
376 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
377 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
379 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
380 heatParameterDefinition.setCurrentValue(updateValueParam);
382 artifacJavaObject.setHeatParameters(heatParameters2);
383 artifacJavaObject.setPayloadData(null);
385 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
386 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
388 // verify change in update response
390 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
391 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
392 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
393 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
394 String verify = updateValueParam;
395 AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
398 // verify change in getResource
400 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
402 Resource resourceRespJavaObject = ResponseParser
403 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
404 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
405 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
406 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
407 String verify = updateValueParam;
408 AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
411 // create MAP from received JSON
413 String section2extract = "heatParameters";
414 String createKeyMapBy = "name";
415 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
416 section2extract, createKeyMapBy);
418 // Prepare map to validate JS
420 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
424 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
429 public void updateValueParamNull() throws Exception {
431 String updateValueParam = null;
433 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
435 // upload HEAT file and save JSON response
436 ArtifactReqDetails heatArtifactDetails = ElementFactory
437 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
438 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
440 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
441 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
443 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
444 // System.out.println(resourceGetResponse.getResponse().toString());
445 String atifactUniqueId = ResponseParser
446 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
448 ArtifactReqDetails artifacJavaObject = ResponseParser
449 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
450 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
452 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
453 heatParameterDefinition.setCurrentValue(updateValueParam);
455 artifacJavaObject.setHeatParameters(heatParameters2);
456 artifacJavaObject.setPayloadData(null);
458 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
459 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
461 // verify change in update response
462 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
463 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
464 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
465 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
466 // String verify = updateValueParam;
467 if (heatParameterDefinition.getDefaultValue() != null) {
468 AssertJUnit.assertTrue(
469 heatParameterDefinition.getDefaultValue().equals(heatParameterDefinition.getCurrentValue()));
471 AssertJUnit.assertNull("verification failed", heatParameterDefinition.getCurrentValue());
475 // verify change in getResource
476 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
478 Resource resourceRespJavaObject = ResponseParser
479 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
480 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
481 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
482 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
483 // String verify = updateValueParam;
484 if (heatParameterDefinition.getDefaultValue() != null) {
485 AssertJUnit.assertTrue(
486 heatParameterDefinition.getDefaultValue().equals(heatParameterDefinition.getCurrentValue()));
488 AssertJUnit.assertNull("verification failed", heatParameterDefinition.getCurrentValue());
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);
498 // Prepare map to validate JS
499 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
502 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
507 public void updateValueParamEmpty() throws Exception {
509 String updateValueParam = "";
511 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
513 // upload HEAT file and save JSON response
515 ArtifactReqDetails heatArtifactDetails = ElementFactory
516 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
517 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
519 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
520 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
522 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
523 // System.out.println(resourceGetResponse.getResponse().toString());
524 String atifactUniqueId = ResponseParser
525 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
527 ArtifactReqDetails artifacJavaObject = ResponseParser
528 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
529 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
531 for (HeatParameterDefinition heatParameterDefinition : heatParameters2) {
532 heatParameterDefinition.setCurrentValue(updateValueParam);
534 artifacJavaObject.setHeatParameters(heatParameters2);
535 artifacJavaObject.setPayloadData(null);
537 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
538 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
540 // verify change in update response
542 ArtifactDefinition ArtifactDefinitionRespJavaObject = ResponseParser
543 .convertArtifactDefinitionResponseToJavaObject(updateInformationalArtifactToResource.getResponse());
544 List<HeatParameterDataDefinition> heatParameters = ArtifactDefinitionRespJavaObject.getHeatParameters();
545 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
546 String verify = updateValueParam;
547 AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
550 // verify change in getResource
552 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
554 Resource resourceRespJavaObject = ResponseParser
555 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
556 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
557 deploymentArtifacts.get(heatArtifactDetails.getArtifactName());
558 for (HeatParameterDataDefinition heatParameterDefinition : heatParameters) {
559 String verify = updateValueParam;
560 AssertJUnit.assertTrue("verification failed", verify.equals(heatParameterDefinition.getCurrentValue()));
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);
569 // Prepare map to validate JS
570 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
573 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);
578 public void onlyValueParamPermited() throws Exception {
580 Map<String, String> filePayload = selectFileToUpload(pathToFile, heatWithValidParams);
582 // upload HEAT file and save JSON response
583 ArtifactReqDetails heatArtifactDetails = ElementFactory
584 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
585 heatArtifactDetails.setPayload(filePayload.get(encodedPayload));
587 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(
588 heatArtifactDetails, sdncDesignerDetails, resourceDetails.getUniqueId());
590 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
591 // System.out.println(resourceGetResponse.getResponse().toString());
592 String atifactUniqueId = ResponseParser
593 .getValueFromJsonResponse(addInformationalArtifactToResource.getResponse(), "uniqueId");
595 ArtifactReqDetails artifacJavaObject = ResponseParser
596 .convertArtifactReqDetailsToJavaObject(addInformationalArtifactToResource.getResponse());
597 List<HeatParameterDefinition> heatParameters2 = artifacJavaObject.getHeatParameters();
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");
606 artifacJavaObject.setHeatParameters(heatParameters2);
607 artifacJavaObject.setPayloadData(null);
609 RestResponse updateInformationalArtifactToResource = ArtifactRestUtils.updateDeploymentArtifactToResource(
610 artifacJavaObject, sdncDesignerDetails, resourceDetails.getUniqueId());
612 resourceGetResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails);
614 // create MAP from received JSON
616 String section2extract = "heatParameters";
617 String createKeyMapBy = "name";
618 Map<String, Map<String, String>> mapOfActualParameters = jsonToMap(addInformationalArtifactToResource,
619 section2extract, createKeyMapBy);
621 // Prepare map to validate JS
623 Map<String, Map> paramters = createMapFromYaml(filePayload.get(decodedPayload));
627 ResourceValidationUtils.compareElements(mapOfActualParameters, paramters);