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.imports;
23 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_CREATED;
24 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_INVALID_CONTENT;
25 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
26 import static org.testng.AssertJUnit.assertEquals;
27 import static org.testng.AssertJUnit.assertFalse;
28 import static org.testng.AssertJUnit.assertNotNull;
29 import static org.testng.AssertJUnit.assertTrue;
32 import java.io.IOException;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.HashMap;
36 import java.util.HashSet;
37 import java.util.Iterator;
38 import java.util.List;
41 import org.apache.http.client.ClientProtocolException;
42 import org.junit.Rule;
43 import org.junit.rules.TestName;
44 import org.openecomp.sdc.be.dao.api.ActionStatus;
45 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
46 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
47 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
48 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
49 import org.openecomp.sdc.be.model.CapReqDef;
50 import org.openecomp.sdc.be.model.CapabilityDefinition;
51 import org.openecomp.sdc.be.model.ComponentInstance;
52 import org.openecomp.sdc.be.model.LifecycleStateEnum;
53 import org.openecomp.sdc.be.model.PropertyDefinition;
54 import org.openecomp.sdc.be.model.RelationshipImpl;
55 import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
56 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
57 import org.openecomp.sdc.be.model.RequirementDefinition;
58 import org.openecomp.sdc.be.model.Resource;
59 import org.openecomp.sdc.be.model.User;
60 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
61 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
62 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
63 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
64 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
65 import org.openecomp.sdc.ci.tests.datatypes.ImportReqDetails;
66 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
67 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
68 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
69 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
70 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
71 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
72 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
73 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
74 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
75 import org.openecomp.sdc.ci.tests.utils.DbUtils;
76 import org.openecomp.sdc.ci.tests.utils.Decoder;
77 import org.openecomp.sdc.ci.tests.utils.Utils;
78 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
79 import org.openecomp.sdc.ci.tests.utils.general.ImportUtils;
80 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
81 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
82 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
83 import org.openecomp.sdc.ci.tests.utils.rest.ComponentRestUtils;
84 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
85 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
86 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
87 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
88 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
89 import org.openecomp.sdc.common.api.ToscaNodeTypeInfo;
90 import org.slf4j.Logger;
91 import org.slf4j.LoggerFactory;
92 import org.testng.AssertJUnit;
93 import org.testng.annotations.BeforeMethod;
94 import org.testng.annotations.DataProvider;
95 import org.testng.annotations.Test;
97 import aj.org.objectweb.asm.Attribute;
101 * @author Andrey + Pavel + Shay
105 public class ImportToscaResourceTest extends ComponentBaseTest {
106 private static Logger logger = LoggerFactory.getLogger(ImportToscaResourceTest.class.getName());
107 protected Utils utils = new Utils();
109 public ImportToscaResourceTest() {
110 super(name, ImportToscaResourceTest.class.getName());
113 public ImportReqDetails importReqDetails;
114 protected static User sdncUserDetails;
115 protected static User testerUser;
116 protected String testResourcesPath;
117 protected ResourceReqDetails resourceDetails;
118 private HashSet<String> capabilitySources;
119 private int actualNumOfReqOrCap;
122 public static TestName name = new TestName();
125 public void before() throws Exception {
126 importReqDetails = ElementFactory.getDefaultImportResource();
127 sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
128 testerUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
129 resourceDetails = ElementFactory.getDefaultResource();
130 String sourceDir = config.getResourceConfigDir();
131 final String workDir = "importToscaResourceByCreateUrl";
132 testResourcesPath = sourceDir + File.separator + workDir;
133 capabilitySources = new HashSet<String>();
134 actualNumOfReqOrCap = 0;
138 private static final Object[][] getYmlWithInValidListProperties() throws IOException, Exception {
139 return new Object[][] { { "ListPropertyFalure02.yml", "[false,\"truee\"]", "boolean" },
140 { "ListPropertyFalure03.yml", "[false,3]", "boolean" },
141 { "ListPropertyFalure04.yml", "[false,3.56]", "boolean" },
142 { "ListPropertyFalure05.yml", "[10000,3.56]", "integer" },
143 { "ListPropertyFalure06.yml", "[10000,\"aaaa\"]", "integer" },
144 { "ListPropertyFalure07.yml", "[10000,true]", "integer" },
145 { "ListPropertyFalure08.yml", "[10.5,true]", "float" },
146 { "ListPropertyFalure09.yml", "[10.5,\"asdc\"]", "float" }, // type
148 { "ListPropertyFalure11.yml", "[10.5,\"500.0@\"]", "float" }, // property
157 { "ListPropertyFalure12.yml", "[10000,\"3#\"]", "integer" }, // property
166 { "ListPropertyFalure13.yml", "[false,\"true%\"]", "boolean" }, // property
175 { "ListPropertyFalure14.yml", "[false,\"falsee\",true]", "boolean" },
176 { "ListPropertyFalure15.yml", "[10.5,\"10.6x\",20.5,30.5]", "float" } // float
187 private static final Object[][] getYmlWithInValidMapProperties() throws IOException, Exception {
188 return new Object[][] { { "MapPropertyFalure02.yml", "[false,\"truee\"]", "boolean" },
189 { "MapPropertyFalure03.yml", "[false,3]", "boolean" },
190 { "MapPropertyFalure04.yml", "[false,3.56]", "boolean" },
191 { "MapPropertyFalure05.yml", "[10000,3.56]", "integer" },
192 { "MapPropertyFalure06.yml", "[10000,\"aaaa\"]", "integer" },
193 { "MapPropertyFalure07.yml", "[10000,true]", "integer" },
194 { "MapPropertyFalure08.yml", "[10.5,true]", "float" },
195 { "MapPropertyFalure09.yml", "[10.5,\"asdc\"]", "float" }, // type
197 { "MapPropertyFalure11.yml", "[10.5,\"500.0@\"]", "float" }, // property
206 { "MapPropertyFalure12.yml", "[10000,\"3#\"]", "integer" }, // property
215 { "MapPropertyFalure13.yml", "[false,\"true%\"]", "boolean" }, // property
224 { "MapPropertyFalure14.yml", "[false,\"falsee\",true]", "boolean" },
225 { "MapPropertyFalure15.yml", "[10.5,\"10.6x\",20.5,30.5]", "float" } // float
236 private static final Object[][] getYmlWithInValidOccurrences() throws IOException, Exception {
237 return new Object[][] { { "occurencyFalure01.yml" }, // requirements [2
239 { "occurencyFalure02.yml" }, // requirements [-1, 2]
240 { "occurencyFalure03.yml" }, // requirements [1 ,-2]
241 { "occurencyFalure05.yml" }, // requirements MAX occurrences not
243 { "occurencyFalure06.yml" }, // requirements [ 0 , 0 ]
244 { "occurencyFalure08.yml" }, // requirements [ 1.0 , 2.0 ]
245 { "occurencyFalure09.yml" }, // requirements [ "1" , "2" ]
246 { "occurencyFalure10.yml" }, // requirements [ ]
247 { "occurencyFalure11.yml" }, // requirements [ UNBOUNDED ,
249 { "occurencyFalure31.yml" }, // capability [ 2, 1]
250 { "occurencyFalure32.yml" }, // capability [-1, 2]
251 { "occurencyFalure33.yml" }, // capability [1, -2]
252 { "occurencyFalure35.yml" }, // capability MAX occurrences not
254 { "occurencyFalure36.yml" }, // capability [ 0 , 0 ]
255 { "occurencyFalure38.yml" }, // capability [ 1.0 , 2.0 ]
256 { "occurencyFalure39.yml" }, // capability [ "1" , "2" ]
257 { "occurencyFalure40.yml" }, // capability [ ]
258 { "occurencyFalure41.yml" } // capability [ UNBOUNDED ,
264 private static final Object[][] getInvalidYmlWithOccurrences() throws IOException, Exception {
265 return new Object[][] { { "occurencyFalure04.yml" }, // requirements MIN
269 { "occurencyFalure07.yml" }, // requirements [ @ , 1 ]
270 { "occurencyFalure34.yml" }, // capability MIN occurrences not
272 { "occurencyFalure37.yml" } // capability [ 0 , # ]
278 protected final String importMapPropertySuccess = "importMapPropertySuccessFlow.yml";
279 protected final String importAttributeSuccess = "importAttributeSuccessFlow.yml";
280 protected final String importSuccessFile = "myCompute.yml";
281 protected final String derivedFromMyCompute = "derivedFromMyCompute.yml";
282 protected final String importSuccessVFFile = "myComputeVF.yml";
283 protected final String importNoDerivedFromFile = "myComputeDerivedFromNotExists.yml";
284 protected final String importInvalidDefinitionVersionFile = "myComputeIncorrectDefenitionVersionValue.yml";
285 protected final String importIncorrectNameSpaceFormatFile = "myComputeIncorrectNameSpaceFormat.yml";
286 protected final String importNoDefenitionVersionFile = "myComputeNoDefenitionVersion.yml";
287 protected final String importNodeTypesTwiceFile = "myComputeWithNodeTypesTwice.yml";
288 protected final String importTopologyTemplateFile = "myComputeWithTopologyTemplate.yml";
289 protected final String importNoContentFile = "noContent.yml";
290 protected final String importWithOccurrences = "myComputeOccurencySuccess.yml";
291 protected final String importListPropertyBadDefault = "importListPropertyBadDefault.yml";
292 protected final String importListPropertyGoodDefault = "importListPropertyGoodDefault.yml";
293 protected final String importListPropertySuccess = "importListPropertySuccessFlow.yml";
295 protected final String importDuplicateRequirements = "importDuplicateRequirements.yml";
296 protected final String importDuplicateCapability = "importDuplicateCapability.yml";
297 protected final String importCapabilityNameExistsOnParent = "importCapabilityNameExistsOnParent.yml";
298 protected final String importRequirementNameExistsOnParent = "importRequirementNameExistsOnParent.yml";
299 protected final String importToscaResourceReqCapDerivedFromParent = "derivedFromWebAppDerivedReqCap.yml";
300 protected final String missingCapInReqDef = "missingCapInReqDefinition.yml";
301 protected final String missingCapInCapDef = "missingCapInCapDefinition.yml";
303 // US558432 - Support for Capability/Requirement "occurences" Import
304 @Test(dataProvider = "getYmlWithInValidOccurrences")
305 public void importToscaResourceWithOccurrencesFailuresFlow01(String ymlFileWithInvalidCapReqOccurrences)
307 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
308 ymlFileWithInvalidCapReqOccurrences);
309 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
311 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
312 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_OCCURRENCES.name(), new ArrayList<String>(),
313 importResourceResponse.getResponse());
316 @Test(dataProvider = "getInvalidYmlWithOccurrences")
317 public void importToscaResourceWithOccurrencesFailuresFlow02(String ymlFileWithInvalidCapReqOccurrences)
319 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
320 ymlFileWithInvalidCapReqOccurrences);
321 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
323 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
324 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_YAML_FILE.name(), new ArrayList<String>(),
325 importResourceResponse.getResponse());
329 public void importToscaResource() throws Exception {
331 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
333 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
335 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
336 AssertJUnit.assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
337 importResourceResponse.getErrorCode() == 201);
338 ToscaNodeTypeInfo parseToscaNodeYaml = utils
339 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
340 Resource resourceJavaObject = ResponseParser
341 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
342 AssertJUnit.assertTrue("validate toscaResourceName field",
343 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
344 AssertJUnit.assertTrue("validate resourceType field",
345 resourceJavaObject.getResourceType().equals(ResourceTypeEnum.VFC));
346 // find derived from resource details
347 // Validate resource details after import-create resource including
348 // capabilities, interfaces from derived_from resource
350 // Validate audit message
351 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
352 .getDefaultImportResourceAuditMsgSuccess();
353 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
354 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
355 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
356 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
357 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
358 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
362 public void importToscaResourceWithOccurrencesSuccessFlow() throws Exception {
364 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
365 importWithOccurrences);
366 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
368 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
369 AssertJUnit.assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
370 importResourceResponse.getErrorCode() == 201);
371 ToscaNodeTypeInfo parseToscaNodeYaml = utils
372 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
373 Resource resourceJavaObject = ResponseParser
374 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
375 AssertJUnit.assertTrue("validate toscaResourceName field",
376 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
377 AssertJUnit.assertTrue("validate resourceType field",
378 resourceJavaObject.getResourceType().equals(ResourceTypeEnum.VFC));
379 String requirementsType = "tosca.capabilities.Attachment";
380 String capabilitType = "tosca.capabilities.Endpoint.Admin";
381 // Verify Occurrences of requirements and capabilities in resource
382 verifyRequirementsOccurrences(resourceJavaObject, requirementsType);
383 verifyCapabilitiesOccurrences(resourceJavaObject, capabilitType);
384 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
385 .getDefaultImportResourceAuditMsgSuccess();
386 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
387 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
388 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
389 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
390 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
391 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
394 // ------------------------------Success---------------------------------
396 @Test(enabled = false)
397 public void importToscaResourceVFResType() throws Exception {
399 String resourceType = ResourceTypeEnum.VF.toString();
401 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
402 importSuccessVFFile);
403 // importReqDetails.setResourceType(resourceType);
404 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
406 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
407 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
408 importResourceResponse.getErrorCode() == 201);
409 ToscaNodeTypeInfo parseToscaNodeYaml = utils
410 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
411 Resource resourceJavaObject = ResponseParser
412 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
413 assertTrue("validate toscaResourceName field",
414 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
416 "validate resourceType field, expected - " + resourceType + ", actual - "
417 + resourceJavaObject.getResourceType(),
418 resourceJavaObject.getResourceType().toString().equals(resourceType));
420 // Validate audit message
421 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
422 .getDefaultImportResourceAuditMsgSuccess();
423 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
424 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
425 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
426 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
427 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
428 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
431 // ------------------------------Failure---------------------------------
434 public void importToscaResourceDerivedFromNotExist() throws Exception {
436 String fileName = importNoDerivedFromFile;
437 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
439 // List<String> derivedFrom = new ArrayList<String>() ;
440 // derivedFrom.add("hh");
441 // importReqDetails.setDerivedFrom(derivedFrom);
442 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
444 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
446 // Validate audit message
447 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
448 assertNotNull("check error code exists in response after import tosca resource",
449 importResourceResponse.getErrorCode());
451 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.PARENT_RESOURCE_NOT_FOUND.name());
452 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
453 importResourceResponse.getErrorCode());
454 List<String> variables = Arrays.asList();
455 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.PARENT_RESOURCE_NOT_FOUND.name(), variables,
456 importResourceResponse.getResponse());
458 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
459 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
460 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
461 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
462 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
463 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
464 ToscaNodeTypeInfo parseToscaNodeYaml = utils
465 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
466 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
467 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
471 public void importToscaResourceIncorrectDefinitionVersion() throws Exception {
473 String fileName = importInvalidDefinitionVersionFile;
474 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
476 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
478 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
480 // Validate audit message
481 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
482 assertNotNull("check error code exists in response after import tosca resource",
483 importResourceResponse.getErrorCode());
485 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_TOSCA_TEMPLATE.name());
486 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
487 importResourceResponse.getErrorCode());
488 List<String> variables = Arrays.asList();
489 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_TOSCA_TEMPLATE.name(), variables,
490 importResourceResponse.getResponse());
492 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
493 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
494 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
495 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
496 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
497 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
498 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
502 public void importToscaResourceIncorrectSpaceNameFormat() throws Exception {
504 String fileName = importIncorrectNameSpaceFormatFile;
505 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
507 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
509 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
511 // Validate audit message
512 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
513 assertNotNull("check error code exists in response after import tosca resource",
514 importResourceResponse.getErrorCode());
516 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_RESOURCE_NAMESPACE.name());
517 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
518 importResourceResponse.getErrorCode());
519 List<String> variables = Arrays.asList();
520 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_RESOURCE_NAMESPACE.name(), variables,
521 importResourceResponse.getResponse());
523 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
524 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
525 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
526 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
527 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
528 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
529 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
533 public void importToscaResourceNoDefinitionVersion() throws Exception {
535 String fileName = importNoDefenitionVersionFile;
536 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
538 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
540 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
542 // Validate audit message
543 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
544 assertNotNull("check error code exists in response after import tosca resource",
545 importResourceResponse.getErrorCode());
547 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_TOSCA_TEMPLATE.name());
548 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
549 importResourceResponse.getErrorCode());
550 List<String> variables = Arrays.asList();
551 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_TOSCA_TEMPLATE.name(), variables,
552 importResourceResponse.getResponse());
554 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
555 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
556 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
557 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
558 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
559 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
560 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
564 public void importToscaResourceNoContent() throws Exception {
566 String fileName = importNoContentFile;
567 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
569 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
571 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
573 // Validate audit message
574 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
575 assertNotNull("check error code exists in response after import tosca resource",
576 importResourceResponse.getErrorCode());
578 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_RESOURCE_PAYLOAD.name());
579 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
580 importResourceResponse.getErrorCode());
581 List<String> variables = Arrays.asList();
582 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_RESOURCE_PAYLOAD.name(), variables,
583 importResourceResponse.getResponse());
585 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
586 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
587 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
588 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
589 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
590 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
591 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
595 public void importToscaResourceWithTopologyTemplate() throws Exception {
597 String fileName = importTopologyTemplateFile;
598 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
600 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
602 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
604 // Validate audit message
605 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
606 assertNotNull("check error code exists in response after import tosca resource",
607 importResourceResponse.getErrorCode());
609 ErrorInfo errorInfo = ErrorValidationUtils
610 .parseErrorConfigYaml(ActionStatus.NOT_RESOURCE_TOSCA_TEMPLATE.name());
611 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
612 importResourceResponse.getErrorCode());
613 List<String> variables = Arrays.asList();
614 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_RESOURCE_TOSCA_TEMPLATE.name(), variables,
615 importResourceResponse.getResponse());
617 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
618 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
619 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
620 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
621 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
622 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
623 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
627 public void importToscaResourceWithNodeTypesTwice() throws Exception {
629 String fileName = importNodeTypesTwiceFile;
630 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
632 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
634 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
636 // Validate audit message
637 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
638 assertNotNull("check error code exists in response after import tosca resource",
639 importResourceResponse.getErrorCode());
641 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.NOT_SINGLE_RESOURCE.name());
642 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
643 importResourceResponse.getErrorCode());
644 List<String> variables = Arrays.asList();
645 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_SINGLE_RESOURCE.name(), variables,
646 importResourceResponse.getResponse());
648 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
649 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
650 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
651 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
652 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
653 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
654 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
657 // failed case - uniqueness of toscaResourceName - RESOURCE_ALREADY_EXISTS
659 public void importToscaResourceTwice() throws Exception {
660 String fileName = importSuccessFile;
661 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
663 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
665 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
666 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
667 importResourceResponse.getErrorCode() == 201);
668 Resource resourceJavaObject = ResponseParser
669 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
670 RestResponse checkInresponse = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
671 LifeCycleStatesEnum.CHECKIN);
672 assertTrue("checkIn resource request returned status:" + checkInresponse.getErrorCode(),
673 checkInresponse.getErrorCode() == 200);
675 // Validate audit message
676 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
677 .getDefaultImportResourceAuditMsgSuccess();
678 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
679 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
680 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
681 ToscaNodeTypeInfo parseToscaNodeYaml = utils
682 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
683 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
684 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
685 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
687 // import the same tosca resource with different resourceName
688 DbUtils.cleanAllAudits();
690 importReqDetails.setName("kuku");
691 List<String> tags = new ArrayList<String>();
692 tags.add(importReqDetails.getName());
693 importReqDetails.setTags(tags);
694 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
695 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
697 // Validate audit message
698 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
699 assertNotNull("check error code exists in response after import tosca resource",
700 importResourceResponse.getErrorCode());
702 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_ALREADY_EXISTS.name());
703 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
704 importResourceResponse.getErrorCode());
705 List<String> variables = Arrays.asList();
706 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_ALREADY_EXISTS.name(), variables,
707 importResourceResponse.getResponse());
709 expectedResourceAuditJavaObject = ElementFactory.getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
710 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
711 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
712 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
713 expectedResourceAuditJavaObject.setToscaNodeType(importReqDetails.getToscaResourceName());
714 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
715 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
720 public void importToscaResourceWithTheSameNameAsCreatedResourceBefore() throws Exception {
723 String fileName = importSuccessFile;
724 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
727 resourceDetails = ElementFactory.getDefaultResource();
728 resourceDetails.setName(importReqDetails.getName());
730 RestResponse response = ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
731 int status = response.getErrorCode();
732 assertEquals("create request returned status:" + status, 201, status);
733 assertNotNull("resource uniqueId is null:", resourceDetails.getUniqueId());
734 Resource resourceJavaObject = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
735 // assertNull("validate toscaResourceName field",
736 // resourceJavaObject.getToscaResourceName());
738 // import the same tosca resource
739 DbUtils.cleanAllAudits();
740 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
742 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
744 // Validate audit message
745 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
746 assertNotNull("check error code exists in response after import tosca resource",
747 importResourceResponse.getErrorCode());
749 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_ALREADY_EXISTS.name());
750 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
751 importResourceResponse.getErrorCode());
752 List<String> variables = Arrays.asList();
753 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_ALREADY_EXISTS.name(), variables,
754 importResourceResponse.getResponse());
756 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
757 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
758 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
759 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
760 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
761 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
762 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
767 public void importToscaResourceInvalidChecksum() throws Exception {
768 String fileName = importSuccessFile;
769 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
771 Map<String, String> headersMap = new HashMap<String, String>();
772 headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), "invalidMd5Sum");
774 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
776 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
778 // Validate audit message
779 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
780 assertNotNull("check error code exists in response after import tosca resource",
781 importResourceResponse.getErrorCode());
783 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_RESOURCE_CHECKSUM.name());
784 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
785 importResourceResponse.getErrorCode());
786 List<String> variables = Arrays.asList();
787 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_RESOURCE_CHECKSUM.name(), variables,
788 importResourceResponse.getResponse());
790 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
791 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
792 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
793 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
794 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
795 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
796 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
800 public void importToscaResourceInvalidResType() throws Exception {
802 String resourceType = "invalidResourceType";
804 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
806 importReqDetails.setResourceType(resourceType);
807 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
810 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_CONTENT.name());
811 assertNotNull("check response object is not null after import resouce", importResourceResponse);
812 assertNotNull("check error code exists in response after import resource",
813 importResourceResponse.getErrorCode());
814 assertEquals("Check response code after import resource", errorInfo.getCode(),
815 importResourceResponse.getErrorCode());
817 List<String> variables = new ArrayList<>();
818 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), variables,
819 importResourceResponse.getResponse());
821 // Validate audit message
822 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
823 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
824 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
825 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
826 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
827 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
828 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
832 public void derivedTemplateImportedSecondResourceAsFirstImportedNodeType() throws Exception {
834 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
836 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
838 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
839 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
840 importResourceResponse.getErrorCode() == 201);
841 ToscaNodeTypeInfo parseToscaNodeYaml = utils
842 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
843 Resource resourceJavaObject = ResponseParser
844 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
845 assertTrue("validate toscaResourceName field",
846 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
848 "validate resourceType field, expected - " + importReqDetails.getResourceType() + ", actual - "
849 + resourceJavaObject.getResourceType(),
850 resourceJavaObject.getResourceType().toString().equals(importReqDetails.getResourceType()));
852 // Validate audit message
853 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
854 .getDefaultImportResourceAuditMsgSuccess();
855 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
856 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
857 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
858 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
859 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
860 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
862 RestResponse certifyResource = LifecycleRestUtils.certifyResource(importReqDetails);
863 assertTrue("certify resource request returned status:" + certifyResource.getErrorCode(),
864 certifyResource.getErrorCode() == 200);
866 // import second resource template derived from first resource
867 DbUtils.cleanAllAudits();
868 importReqDetails.setName("kuku");
869 List<String> tags = new ArrayList<String>();
870 tags.add(importReqDetails.getName());
871 importReqDetails.setTags(tags);
872 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
873 derivedFromMyCompute);
874 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
875 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
877 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
878 importResourceResponse.getErrorCode() == 201);
879 parseToscaNodeYaml = utils.parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
880 Resource resourceJavaObject2 = ResponseParser
881 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
882 assertTrue("validate toscaResourceName field",
883 resourceJavaObject2.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
885 "validate resourceType field, expected - " + importReqDetails.getResourceType() + ", actual - "
886 + resourceJavaObject2.getResourceType(),
887 resourceJavaObject2.getResourceType().toString().equals(importReqDetails.getResourceType()));
889 // Validate audit message
890 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject2 = ElementFactory
891 .getDefaultImportResourceAuditMsgSuccess();
892 expectedResourceAuditJavaObject2.setResourceName(importReqDetails.getName());
893 expectedResourceAuditJavaObject2.setModifierName(sdncUserDetails.getFullName());
894 expectedResourceAuditJavaObject2.setModifierUid(sdncUserDetails.getUserId());
895 expectedResourceAuditJavaObject2.setToscaNodeType(parseToscaNodeYaml.getNodeName());
896 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject2,
897 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
902 public void importToscaResourceListPropertyGoodDefault() throws Exception {
904 String fileName = importListPropertyGoodDefault;
905 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
907 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
909 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
911 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
912 importResourceResponse.getErrorCode() == 201);
914 Resource resourceJavaObject = ResponseParser
915 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
916 assertTrue("Properties size : " + resourceJavaObject.getProperties().size(),
917 resourceJavaObject.getProperties().size() == 1);
918 assertTrue("Property type : " + resourceJavaObject.getProperties().get(0).getType(),
919 resourceJavaObject.getProperties().get(0).getType().equals(ToscaPropertyType.LIST.getType()));
921 "actual Default values : " + resourceJavaObject.getProperties().get(0).getDefaultValue()
922 + " , expected : " + "[false, true]",
923 resourceJavaObject.getProperties().get(0).getDefaultValue().equals("[\"false\",\"true\"]"));
928 public void importToscaResourceListPropertyBadDefault() throws Exception {
930 String fileName = importListPropertyBadDefault;
931 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
933 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
935 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
937 ErrorInfo errorInfo = ErrorValidationUtils
938 .parseErrorConfigYaml(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name());
939 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
940 importResourceResponse.getErrorCode());
941 ArrayList<String> variables = new ArrayList<>();
942 variables.add("my_prop");
943 variables.add("list");
944 variables.add("boolean");
945 variables.add("[12,true]");
946 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name(), variables,
947 importResourceResponse.getResponse());
951 // Benny US580744 - Add support for TOSCA "list" type - import
954 public void importToscaResourceListPropertySuccessFlow() throws Exception {
955 String fileName = importListPropertySuccess;
956 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
958 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
960 ResourceRestUtils.checkCreateResponse(importResourceResponse);
961 Resource resourceJavaObject = ResponseParser
962 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
963 ToscaNodeTypeInfo parseToscaNodeYaml = utils
964 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
965 // Verify Properties List in resource
966 verifyResourcePropertiesList(resourceJavaObject);
967 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
968 .getDefaultImportResourceAuditMsgSuccess();
969 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
970 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
971 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
972 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
973 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
974 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
978 @Test(dataProvider = "getYmlWithInValidListProperties") // invalid default
980 public void importToscaResourceListPropertyFailureFlows(String ymlFileWithInvalidPropertyDefualtValues,
981 String defualtValues, String enterySchemaType) throws Exception {
982 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
983 ymlFileWithInvalidPropertyDefualtValues);
984 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
986 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
987 ArrayList<String> variables = new ArrayList<>();
988 variables.add("my_property");
989 variables.add("list");
990 variables.add(enterySchemaType);
991 variables.add(defualtValues);
992 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name(), variables,
993 importResourceResponse.getResponse());
998 public void importToscaResourceListPropertyNonSupportEntrySchemaType() throws Exception {
999 String ymlFile = "ListPropertyFalure01.yml";
1000 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1002 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1004 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1005 ArrayList<String> variables = new ArrayList<>();
1006 variables.add("booolean"); // property entry_schema data type
1007 variables.add("my_boolean");
1008 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROPERTY_INNER_TYPE.name(), variables,
1009 importResourceResponse.getResponse());
1013 @Test // (enabled=false)
1014 public void importToscaResourceListPropertyNonSupportedPropertyType() throws Exception { // Not
1017 String ymlFile = "ListPropertyFalure16.yml";
1018 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1020 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1022 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1023 ArrayList<String> variables = new ArrayList<>();
1024 variables.add("koko"); // property data type (koko instead list)
1025 variables.add("my_boolean");
1026 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROPERTY_TYPE.name(), variables,
1027 importResourceResponse.getResponse());
1030 /// US656928 - [BE] - Add support for TOSCA "map" type - Phase 1 import
1032 public void importToscaResourceMapPropertySuccessFlow() throws Exception {
1033 String fileName = importMapPropertySuccess;
1034 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1036 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1038 ResourceRestUtils.checkCreateResponse(importResourceResponse);
1039 Resource resourceJavaObject = ResponseParser
1040 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
1041 ToscaNodeTypeInfo parseToscaNodeYaml = utils
1042 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
1043 // Verify Properties MAP in resource
1044 verifyResourcePropertiesMap(resourceJavaObject);
1045 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1046 .getDefaultImportResourceAuditMsgSuccess();
1047 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1048 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1049 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1050 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
1051 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1052 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1055 @Test(dataProvider = "getYmlWithInValidMapProperties") // invalid default
1057 public void importToscaResourceMapPropertyFailureFlows(String ymlFileWithInvalidPropertyDefualtValues,
1058 String defualtValues, String enterySchemaType) throws Exception {
1059 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1060 ymlFileWithInvalidPropertyDefualtValues);
1061 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1063 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1064 ArrayList<String> variables = new ArrayList<>();
1065 variables.add("my_property");
1066 variables.add("map");
1067 variables.add(enterySchemaType);
1068 variables.add(defualtValues);
1069 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name(), variables,
1070 importResourceResponse.getResponse());
1074 public void importToscaResourceMaptPropertyNonSupportedPropertyType() throws Exception { // Not
1077 String ymlFile = "MapPropertyFalure16.yml";
1078 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1080 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1082 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1083 ArrayList<String> variables = new ArrayList<>();
1084 variables.add("koko"); // property data type (koko instead list)
1085 variables.add("my_boolean");
1086 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROPERTY_TYPE.name(), variables,
1087 importResourceResponse.getResponse());
1091 public void importToscaResourceMissingCapabilityInReqDefinition() throws Exception {
1093 String fileName = missingCapInReqDef;
1094 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1096 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1098 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
1100 // Validate audit message
1101 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_CAPABILITY_TYPE.name());
1102 String missingCapName = "org.openecomp.capabilities.networkInterfaceNotFound";
1103 BaseRestUtils.checkErrorResponse(importResourceResponse, ActionStatus.MISSING_CAPABILITY_TYPE, missingCapName);
1105 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1106 .getDefaultImportResourceAuditMsgFailure(errorInfo, Arrays.asList(missingCapName));
1107 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1108 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1109 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1110 expectedResourceAuditJavaObject.setToscaNodeType("org.openecomp.resource.vSCP-03-16");
1111 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1112 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1116 public void importToscaResourceMissingCapabilityInCapDefinition() throws Exception {
1118 String fileName = missingCapInCapDef;
1119 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1121 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1123 logger.debug("import tosca resource response: {}", importResourceResponse.getResponseMessage());
1125 // Validate audit message
1126 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_CAPABILITY_TYPE.name());
1127 String missingCapName = "org.openecomp.capabilities.networkInterfaceNotFound";
1128 BaseRestUtils.checkErrorResponse(importResourceResponse, ActionStatus.MISSING_CAPABILITY_TYPE, missingCapName);
1130 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1131 .getDefaultImportResourceAuditMsgFailure(errorInfo, Arrays.asList(missingCapName));
1132 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1133 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1134 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1135 expectedResourceAuditJavaObject.setToscaNodeType("org.openecomp.resource.vSCP-03-16");
1136 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1137 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1141 public void importToscaResourceDuplicateRequirements() throws Exception {
1142 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1143 importDuplicateRequirements);
1144 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1146 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1147 ArrayList<String> variables = new ArrayList<>();
1148 variables.add("requirement");
1149 variables.add("local_storage");
1150 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name(), variables,
1151 importResourceResponse.getResponse());
1152 ErrorInfo errorInfo = ErrorValidationUtils
1153 .parseErrorConfigYaml(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name());
1154 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1155 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1156 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1157 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1158 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1159 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1160 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1161 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1165 public void importToscaResourceDuplicateCapabilities() throws Exception {
1166 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1167 importDuplicateCapability);
1168 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1170 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1171 ArrayList<String> variables = new ArrayList<>();
1172 variables.add("capability");
1173 variables.add("scalable");
1174 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name(), variables,
1175 importResourceResponse.getResponse());
1176 ErrorInfo errorInfo = ErrorValidationUtils
1177 .parseErrorConfigYaml(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name());
1178 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1179 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1180 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1181 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1182 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1183 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1184 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1185 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1189 public void importToscaResourceRequirementNameExistsOnParent() throws Exception {
1190 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1191 importRequirementNameExistsOnParent);
1192 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1194 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1195 ArrayList<String> variables = new ArrayList<>();
1196 variables.add("requirement");
1197 variables.add("local_storage");
1198 variables.add("Compute");
1199 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1200 variables, importResourceResponse.getResponse());
1201 ErrorInfo errorInfo = ErrorValidationUtils
1202 .parseErrorConfigYaml(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name());
1203 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1204 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1205 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1206 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1207 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1208 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1209 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1210 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1214 public void importToscaResourceCapabilityNameExistsOnParent() throws Exception {
1215 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1216 importCapabilityNameExistsOnParent);
1217 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1219 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1220 ArrayList<String> variables = new ArrayList<>();
1221 variables.add("capability");
1222 variables.add("binding");
1223 variables.add("Compute");
1224 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1225 variables, importResourceResponse.getResponse());
1226 ErrorInfo errorInfo = ErrorValidationUtils
1227 .parseErrorConfigYaml(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name());
1228 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1229 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1230 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1231 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1232 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1233 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1234 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1235 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1239 public void importToscaResourceReqCapDerivedFromParent() throws Exception {
1240 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1241 importToscaResourceReqCapDerivedFromParent);
1242 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1244 BaseRestUtils.checkCreateResponse(importResourceResponse);
1245 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1246 .getDefaultImportResourceAuditMsgSuccess();
1247 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1248 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1249 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1250 expectedResourceAuditJavaObject.setToscaNodeType("org.openecomp.resource.MyWebApp");
1251 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1252 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1255 /************************ Shay ************************/
1258 public void caseRequirementInsensitiveTest() throws Exception {
1259 String fileName = "CaseInsensitiveReqTest_1.yml";
1260 int expectedNumOfRequirements = 2;
1261 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1263 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1265 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1266 importReqDetails.setRequirements(testResourcesPath, fileName, sdncUserDetails, null);
1267 Map<String, Object> requirements = importReqDetails.getRequirements();
1268 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1269 expectedNumOfRequirements);
1270 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1271 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1273 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1274 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1275 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1276 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1277 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1278 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1279 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1280 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1281 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1283 String fileName2 = "CaseInsensitiveReqTest_2.yml";
1284 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1286 importReqDetails.setName("secondImportedResource");
1287 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1288 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1289 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1290 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails, null);
1291 requirements = importReqDetails.getRequirements();
1292 requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1293 expectedNumOfRequirements);
1294 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1295 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1297 checkImportedAssetAssociated(importReqDetails);
1301 private void checkImportedAssetAssociated(ImportReqDetails importDetails) throws IOException, Exception {
1302 RestResponse importResourceResponse;
1303 ImportReqDetails importReqDetails2 = ElementFactory.getDefaultImportResource();
1304 importReqDetails2 = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails2, testResourcesPath,
1305 "BindingAsset.yml");
1306 importReqDetails2.setName("bindingAsset");
1307 importReqDetails2.setTags(Arrays.asList(importReqDetails2.getName()));
1308 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails2, sdncUserDetails, null);
1309 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1311 ResourceReqDetails vf = ElementFactory.getDefaultResourceByType("VF100", NormativeTypesEnum.ROOT,
1312 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncUserDetails.getUserId(),
1313 ResourceTypeEnum.VF.toString());
1314 RestResponse createResourceResponse = ResourceRestUtils.createResource(vf, sdncUserDetails);
1315 ResourceRestUtils.checkCreateResponse(createResourceResponse);
1317 LifecycleRestUtils.changeResourceState(importDetails, sdncUserDetails,
1318 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1319 LifecycleRestUtils.changeResourceState(importReqDetails2, sdncUserDetails,
1320 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1322 RestResponse response = ResourceRestUtils.createResourceInstance(importDetails, sdncUserDetails,
1324 ResourceRestUtils.checkCreateResponse(response);
1325 ComponentInstance riCap = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
1327 response = ResourceRestUtils.createResourceInstance(importReqDetails2, sdncUserDetails, vf.getUniqueId());
1328 ResourceRestUtils.checkCreateResponse(response);
1329 ComponentInstance riReq = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
1331 RestResponse getResourceBeforeAssociate = ComponentRestUtils
1332 .getComponentRequirmentsCapabilities(sdncUserDetails, vf);
1333 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceBeforeAssociate.getResponse(), CapReqDef.class);
1335 String capbilityUid = capReqDef.getCapabilities().get("tosca.capabilities.network.Bindable").get(0)
1337 String requirementUid = capReqDef.getRequirements().get("tosca.capabilities.network.Bindable").get(0)
1340 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1341 requirementDef.setFromNode(riReq.getUniqueId());
1342 requirementDef.setToNode(riCap.getUniqueId());
1344 RequirementAndRelationshipPair pair = new RequirementAndRelationshipPair();
1345 pair.setRequirementOwnerId(riReq.getUniqueId());
1346 pair.setCapabilityOwnerId(riCap.getUniqueId());
1347 pair.setRequirement("VirtualBinding");
1348 RelationshipImpl relationship = new RelationshipImpl();
1349 relationship.setType("tosca.capabilities.network.Bindable");
1350 pair.setRelationships(relationship);
1351 pair.setCapabilityUid(capbilityUid);
1352 pair.setRequirementUid(requirementUid);
1353 List<RequirementAndRelationshipPair> relationships = new ArrayList<>();
1354 relationships.add(pair);
1355 requirementDef.setRelationships(relationships);
1357 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncUserDetails,
1358 vf.getUniqueId(), ComponentTypeEnum.RESOURCE);
1359 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1363 public void caseCapabilitiesInsensitiveTest() throws Exception {
1364 String fileName = "CaseInsensitiveCapTest_1.yml";
1365 int expectedNumOfCapabilities = 6;
1367 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1369 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1371 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1373 importReqDetails.setCapabilities(testResourcesPath, fileName, sdncUserDetails, null);
1374 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1375 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1376 expectedNumOfCapabilities);
1377 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1378 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1380 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1381 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1382 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1383 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1384 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1385 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1386 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1387 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1388 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1390 String fileName2 = "CaseInsensitiveCapTest_2.yml";
1391 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1393 importReqDetails.setName("secondImportedResource");
1394 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1395 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1396 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1398 importReqDetails.setCapabilities(testResourcesPath, fileName2, sdncUserDetails, null);
1399 capabilities = importReqDetails.getCapabilities();
1400 capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1401 expectedNumOfCapabilities);
1402 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1403 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1408 public void fatherAndChildHaveDifferentRequirementsTest() throws Exception {
1409 String fileName = "DifferentReqFromCompute.yml";
1410 int expectedNumOfRequirements = 3;
1412 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1414 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1416 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1418 importReqDetails.setRequirements(testResourcesPath, fileName, sdncUserDetails, "Compute");
1419 Map<String, Object> requirements = importReqDetails.getRequirements();
1420 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1421 expectedNumOfRequirements);
1422 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1423 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1425 checkImportedAssetAssociated(importReqDetails);
1429 public void fatherHasNoRequirementsTest() throws Exception {
1430 String fatherFileName = "CPHasNoReqCap.yml";
1431 String childFileName = "DerivedFromCPWithOwnReq.yml";
1432 int expectedNumOfRequirements = 3;
1434 importReqDetails.setName("father");
1435 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1436 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1438 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1440 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1442 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1443 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1444 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1445 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1446 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1447 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1448 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1449 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1450 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1452 String derivedFromResourceName = importReqDetails.getName();
1453 importReqDetails = ElementFactory.getDefaultImportResource();
1454 importReqDetails.setName("child");
1455 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1456 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1458 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1459 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1461 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1462 derivedFromResourceName);
1463 Map<String, Object> requirements = importReqDetails.getRequirements();
1464 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1465 expectedNumOfRequirements);
1466 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1467 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1472 public void childHasSameReqNameAndTypeLikeFatherTest() throws Exception {
1473 String childFileName = "SameReqAsCompute.yml";
1474 int expectedNumOfRequirements = 2;
1476 importReqDetails.setName("child");
1477 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1478 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1480 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1482 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1484 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails, null);
1485 Map<String, Object> requirements = importReqDetails.getRequirements();
1486 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1487 expectedNumOfRequirements);
1488 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1489 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1493 public void childHasSameCapNameAndTypeLikeFatherTest() throws Exception {
1494 String childFileName = "SameCapAsCompute.yml";
1495 int expectedNumOfCapabilities = 6;
1497 importReqDetails.setName("child");
1498 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1499 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1501 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1503 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1505 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1507 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1508 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1509 expectedNumOfCapabilities);
1510 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1511 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1515 public void childGetsAllRequirementsOfFatherAndGrandfatherTest() throws Exception {
1516 int expectedNumOfRequirements = 4;
1518 String fatherFileName = "DifferentReqFromCompute.yml";
1519 importReqDetails.setName("father");
1520 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1521 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1523 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1525 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1527 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1528 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1529 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1530 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1531 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1532 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1533 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1534 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1535 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1537 String derivedFromName = importReqDetails.getName();
1538 String childFileName = "DifferentReqCapFromCompute1.yml";
1539 importReqDetails = ElementFactory.getDefaultImportResource();
1540 importReqDetails.setName("child");
1541 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1542 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1544 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1545 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1547 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1549 Map<String, Object> requirements = importReqDetails.getRequirements();
1550 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1551 expectedNumOfRequirements);
1552 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1553 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1558 public void childOverridesGrandfatherRequirementsTest() throws Exception {
1559 int expectedNumOfRequirements = 3;
1561 String fatherFileName = "DifferentReqFromCompute.yml";
1562 importReqDetails.setName("father");
1563 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1564 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1566 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1568 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1570 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1571 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1572 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1573 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1574 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1575 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1576 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1577 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1578 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1580 String derivedFromName = importReqDetails.getName();
1581 String childFileName = "SameReqAsCompute_DerivedFromMyCompute1.yml";
1582 importReqDetails = ElementFactory.getDefaultImportResource();
1583 importReqDetails.setName("child");
1584 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1585 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1587 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1588 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1590 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1592 Map<String, Object> requirements = importReqDetails.getRequirements();
1593 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1594 expectedNumOfRequirements);
1595 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1596 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1600 public void childAndGrandfatherHaveDifferenetReqiurementTypeTest() throws Exception {
1601 int expectedNumOfRequirements = 3;
1602 int expectedNumOfCapabilities = 6;
1604 String fatherName = "father";
1605 String fatherFileName = "DifferentReqFromCompute.yml";
1606 importReqDetails.setName(fatherName);
1607 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1608 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1610 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1612 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1614 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1615 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1616 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1617 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1618 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1619 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1620 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1621 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1622 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1624 String fatherUniqueId = importReqDetails.getUniqueId();
1625 ImportReqDetails importReqDetailsFather = importReqDetails;
1627 String childFileName = "importRequirementNameExistsOnParent_DerivedFromMyCompute1.yml";
1628 importReqDetails = ElementFactory.getDefaultImportResource();
1629 importReqDetails.setName("child");
1630 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1631 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1633 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1634 assertEquals(STATUS_CODE_INVALID_CONTENT, importResourceResponse.getErrorCode().intValue());
1635 ArrayList<String> variables = new ArrayList<>();
1636 variables.add("requirement");
1637 variables.add("local_storage");
1638 variables.add(fatherName);
1639 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1640 variables, importResourceResponse.getResponse());
1642 importReqDetails.setUniqueId(fatherUniqueId);
1644 importReqDetailsFather.setRequirements(testResourcesPath, fatherFileName, sdncUserDetails, "Compute");
1645 Map<String, Object> requirements = importReqDetailsFather.getRequirements();
1646 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetailsFather,
1647 expectedNumOfRequirements);
1648 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1649 importReqDetailsFather.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1651 importReqDetailsFather.setCapabilities(testResourcesPath, fatherFileName, sdncUserDetails, "Compute");
1652 Map<String, Object> capabilities = importReqDetailsFather.getCapabilities();
1653 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetailsFather,
1654 expectedNumOfCapabilities);
1655 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1656 importReqDetailsFather.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1660 public void childHasNoReqCapTest() throws Exception {
1661 int expectedNumOfRequirements = 3;
1662 int expectedNumOfCapabilities = 6;
1664 String fatherFileName = "DifferentReqFromCompute.yml";
1665 importReqDetails.setName("father");
1666 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1667 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1669 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1671 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1673 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1674 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1675 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1676 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1677 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1678 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1679 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1680 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1681 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1683 String derivedFromName = importReqDetails.getName();
1684 String childFileName = "CPHasNoReqCap_DerivedFromMyCompute1.yml";
1685 importReqDetails = ElementFactory.getDefaultImportResource();
1686 importReqDetails.setName("child");
1687 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1688 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1690 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1691 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1693 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1695 Map<String, Object> requirements = importReqDetails.getRequirements();
1696 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1697 expectedNumOfRequirements);
1698 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1699 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1701 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1703 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1704 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1705 expectedNumOfCapabilities);
1706 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1707 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1711 public void fatherAndChildGetReqCapFromGrandfatherTest() throws Exception {
1712 int expectedNumOfRequirements = 2;
1713 int expectedNumOfCapabilities = 6;
1715 String fatherFileName = "MyFatherCompute_NoReqCap.yml";
1716 importReqDetails.setName("father");
1717 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1718 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1720 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1722 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1724 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1725 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1726 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1727 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1728 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1729 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1730 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1731 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1732 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1734 String derivedFromName = importReqDetails.getName();
1735 String childFileName = "myChildCompute_NoReqCap.yml";
1736 importReqDetails = ElementFactory.getDefaultImportResource();
1737 importReqDetails.setName("child");
1738 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1739 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1741 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1742 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1744 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1746 Map<String, Object> requirements = importReqDetails.getRequirements();
1747 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1748 expectedNumOfRequirements);
1749 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1750 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1752 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1754 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1755 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1756 expectedNumOfCapabilities);
1757 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1758 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1762 public void reverseInheritanceTest() throws Exception {
1763 int expectedNumOfRequirements = 2;
1764 int expectedNumOfCapabilities = 2;
1766 String fatherName = "father";
1767 String fatherFileName = "myFatherWebApp_derviedFromDocker.yml";
1768 importReqDetails.setName(fatherName);
1769 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1770 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1772 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1774 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1776 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1777 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1778 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1779 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1780 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1781 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1782 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1783 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1784 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1786 String fatherUniqueId = importReqDetails.getUniqueId();
1787 ImportReqDetails importReqDetailsFather = importReqDetails;
1788 String childFileName = "myChildWebApp_DerivedFromContainer.yml";
1789 importReqDetails = ElementFactory.getDefaultImportResource();
1790 importReqDetails.setName("child");
1791 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1792 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1794 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1795 assertEquals(STATUS_CODE_INVALID_CONTENT, importResourceResponse.getErrorCode().intValue());
1796 ArrayList<String> variables = new ArrayList<>();
1797 variables.add("requirement");
1798 variables.add("host");
1799 variables.add(fatherName);
1800 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1801 variables, importResourceResponse.getResponse());
1803 importReqDetails.setUniqueId(fatherUniqueId);
1804 importReqDetailsFather.setRequirements(testResourcesPath, fatherFileName, sdncUserDetails, "Root");
1805 Map<String, Object> requirements = importReqDetailsFather.getRequirements();
1806 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetailsFather,
1807 expectedNumOfRequirements);
1808 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1809 importReqDetailsFather.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1811 importReqDetailsFather.setCapabilities(testResourcesPath, fatherFileName, sdncUserDetails, "Root");
1812 Map<String, Object> capabilities = importReqDetailsFather.getCapabilities();
1813 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetailsFather,
1814 expectedNumOfCapabilities);
1815 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1816 importReqDetailsFather.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1820 @Test(enabled = false)
1821 public void requirementWithMissingTypeTest() throws Exception {
1822 String fatherName = "father";
1823 String fatherFileName = "DerivedFromWebApplication_HasNoReqType.yml";
1824 importReqDetails.setName(fatherName);
1825 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1826 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1828 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1830 assertEquals(STATUS_CODE_INVALID_CONTENT, importResourceResponse.getErrorCode().intValue());
1831 ArrayList<String> variables = new ArrayList<>();
1832 variables.add("diff");
1833 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_CAPABILITY_TYPE.name(), variables,
1834 importResourceResponse.getResponse());
1839 public void TwinBrothersHaveSameReqCapTest() throws Exception {
1840 int expectedNumOfRequirements = 4;
1841 int expectedNumOfCapabilities = 7;
1843 String derivedFromName = "father";
1844 String fatherFileName = "DifferentReqFromCompute.yml";
1845 importReqDetails.setName(derivedFromName);
1846 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1847 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1849 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1851 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1853 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1854 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1855 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1856 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1857 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1858 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1859 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1860 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1861 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1863 String childFileName = "DifferentReqCapFromCompute1.yml";
1864 importReqDetails = ElementFactory.getDefaultImportResource();
1865 importReqDetails.setName("child");
1866 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1867 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1869 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1870 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1872 Map<String, Object> childRequirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1873 expectedNumOfRequirements);
1874 Map<String, Object> childCapabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1875 expectedNumOfCapabilities - 1);
1877 String twinFileName = "DifferentReqCapFromCompute2.yml";
1878 importReqDetails = ElementFactory.getDefaultImportResource();
1879 importReqDetails.setName("twin");
1880 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1881 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1883 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1884 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1886 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1888 Map<String, Object> requirements = importReqDetails.getRequirements();
1889 Map<String, Object> twinRequirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1890 expectedNumOfRequirements);
1891 assertEquals(requirements.keySet().size(), twinRequirementsFromResponse.keySet().size());
1892 importReqDetails.compareRequirementsOrCapabilities(requirements, twinRequirementsFromResponse);
1894 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1896 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1897 Map<String, Object> twinCapabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1898 expectedNumOfCapabilities);
1899 assertEquals(capabilities.keySet().size(), twinCapabilitiesFromResponse.keySet().size());
1900 importReqDetails.compareRequirementsOrCapabilities(capabilities, twinCapabilitiesFromResponse);
1902 assertEquals(childRequirementsFromResponse.keySet().size(), twinRequirementsFromResponse.keySet().size());
1903 assertEquals(childCapabilitiesFromResponse.keySet().size(), twinCapabilitiesFromResponse.keySet().size());
1907 * invariantUUID - US672129
1910 private void checkInvariantUuidIsImmutableInDifferentAction(ImportReqDetails importReqDetails) throws Exception {
1912 importReqDetails.setName("import");
1913 String invariantUuidDefinedByUser = "abcd1234";
1914 RestResponse importResourceResponse = importResourceWithRequestedInvariantUuid(importReqDetails,
1915 invariantUuidDefinedByUser);
1916 String invariantUUIDcreation = ResponseParser.getInvariantUuid(importResourceResponse);
1917 assertFalse(checkInvariantUuidEqual(invariantUuidDefinedByUser, importResourceResponse));
1920 RestResponse getResource = ResourceRestUtils.getResource(importReqDetails.getUniqueId());
1921 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, getResource));
1924 RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1925 LifeCycleStatesEnum.CHECKIN);
1926 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1927 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1929 // checkout resource
1930 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1931 LifeCycleStatesEnum.CHECKOUT);
1932 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1933 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1936 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1937 LifeCycleStatesEnum.CHECKIN);
1938 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1939 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1941 // checkout resource
1942 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1943 LifeCycleStatesEnum.CHECKOUT);
1944 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1945 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1948 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1949 LifeCycleStatesEnum.CHECKIN);
1950 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1951 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1953 // certification request
1954 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1955 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1956 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1957 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1959 // start certification
1960 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
1961 LifeCycleStatesEnum.STARTCERTIFICATION);
1962 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1963 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1966 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
1967 LifeCycleStatesEnum.CERTIFY);
1968 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1969 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1970 String certifiedUniqueId = importReqDetails.getUniqueId();
1973 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1974 LifeCycleStatesEnum.CHECKOUT);
1975 ResourceReqDetails updatedResourceReqDetails = new ResourceReqDetails(importReqDetails,
1976 importReqDetails.getVersion());
1977 updatedResourceReqDetails.setDescription("updatedDescription");
1978 updatedResourceReqDetails.setVendorRelease("1.2.3.4");
1979 RestResponse updateResponse = ResourceRestUtils.updateResourceMetadata(updatedResourceReqDetails,
1980 sdncUserDetails, importReqDetails.getUniqueId());
1981 assertEquals(STATUS_CODE_SUCCESS, updateResponse.getErrorCode().intValue());
1982 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, updateResponse));
1984 // certification request
1985 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1986 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1987 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1988 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1990 // checkout resource
1991 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1992 LifeCycleStatesEnum.CHECKOUT);
1993 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1994 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1996 // certification request
1997 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1998 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1999 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2000 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2002 // start certification
2003 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2004 LifeCycleStatesEnum.STARTCERTIFICATION);
2005 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2006 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2008 // cancel certification
2009 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2010 LifeCycleStatesEnum.CANCELCERTIFICATION);
2011 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2012 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2014 // start certification
2015 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2016 LifeCycleStatesEnum.STARTCERTIFICATION);
2017 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2018 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2021 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2022 LifeCycleStatesEnum.FAILCERTIFICATION);
2023 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2024 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2027 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
2028 LifeCycleStatesEnum.CHECKOUT);
2029 ArtifactReqDetails artifactDetails = ElementFactory.getDefaultArtifact();
2030 ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails, sdncUserDetails,
2031 importReqDetails.getUniqueId());
2032 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2033 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2036 resourceDetails.setResourceType(ResourceTypeEnum.VF.toString());
2037 ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
2038 importReqDetails.setUniqueId(certifiedUniqueId);
2039 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory
2040 .getComponentResourceInstance(importReqDetails);
2041 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
2042 resourceInstanceReqDetails, sdncUserDetails, resourceDetails.getUniqueId(), ComponentTypeEnum.RESOURCE);
2043 assertEquals(STATUS_CODE_CREATED, createResourceInstanceResponse.getErrorCode().intValue());
2044 getResource = ResourceRestUtils.getResource(importReqDetails.getUniqueId());
2045 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, getResource));
2048 private boolean checkInvariantUuidEqual(String expectedInvariantUuid, RestResponse response) {
2049 String invariantUUIDFromResponse = ResponseParser.getInvariantUuid(response);
2050 return expectedInvariantUuid.equals(invariantUUIDFromResponse);
2054 public void checkCPHasImmutableInvariantUuidTest() throws Exception {
2055 String filename = "FatherHasNoReqCap.yml";
2056 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
2058 checkResourceHasImmutableInvariantUuidTest(importReqDetails);
2062 public void checkVFCHasImmutableInvariantUuidTest() throws Exception {
2063 String filename = "computeCap11.yml";
2064 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
2066 checkResourceHasImmutableInvariantUuidTest(importReqDetails);
2069 public void checkResourceHasImmutableInvariantUuidTest(ImportReqDetails importReqDetails) throws Exception {
2070 // invariantUuid is null
2071 importReqDetails.setName("first");
2072 RestResponse importResourceResponse = importResourceWithRequestedInvariantUuid(importReqDetails, null);
2073 String invariantUUIDcreation = ResponseParser.getInvariantUuid(importResourceResponse);
2074 assertNotNull(invariantUUIDcreation);
2076 ResourceRestUtils.deleteResource(importReqDetails.getUniqueId(), sdncUserDetails.getUserId());
2078 // invariantUuid is empty
2079 importReqDetails.setName("second");
2080 String invariantUuidDefinedByUser = "";
2081 importResourceResponse = importResourceWithRequestedInvariantUuid(importReqDetails, invariantUuidDefinedByUser);
2082 invariantUUIDcreation = ResponseParser.getInvariantUuid(importResourceResponse);
2083 assertNotNull(invariantUUIDcreation);
2085 ResourceRestUtils.deleteResource(importReqDetails.getUniqueId(), sdncUserDetails.getUserId());
2087 checkInvariantUuidIsImmutableInDifferentAction(importReqDetails);
2090 private static RestResponse importResourceWithRequestedInvariantUuid(ImportReqDetails importDetails,
2091 String invariantUuid) throws Exception {
2092 importDetails.setInvariantUUID(invariantUuid);
2093 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importDetails, sdncUserDetails,
2095 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
2096 return importResourceResponse;
2099 private Map<String, Object> parseReqOrCapFromResponse(String parsedFieldName, ImportReqDetails importReqDetails,
2100 int expectedNumOfReqCap) throws ClientProtocolException, IOException {
2101 RestResponse getResource = ResourceRestUtils.getResource(importReqDetails.getUniqueId());
2102 assertTrue(getResource.getErrorCode().equals(STATUS_CODE_SUCCESS));
2103 Map<String, Object> parsedFieldFromResponseToMap = ResponseParser.getJsonValueAsMap(getResource,
2105 Iterator<String> iterator = parsedFieldFromResponseToMap.keySet().iterator();
2106 actualNumOfReqOrCap = 0;
2107 while (iterator.hasNext()) {
2108 String next = iterator.next();
2109 List<Object> object = (List<Object>) parsedFieldFromResponseToMap.get(next);
2110 actualNumOfReqOrCap += object.size();
2112 assertEquals(expectedNumOfReqCap, actualNumOfReqOrCap);
2113 return parsedFieldFromResponseToMap;
2116 // ---------------------------------
2118 private void verifyResourcePropertiesList(Resource resourceJavaObject) { // use
2119 // importListPropertySuccessFlow.yml
2120 boolean isPropertyAppear = false;
2121 List<PropertyDefinition> propertiesList = resourceJavaObject.getProperties();
2122 for (PropertyDefinition pro : propertiesList) {
2123 switch (pro.getName()) {
2125 assertTrue("Check Property Type ", pro.getType().equals("list"));
2126 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[false,true]"));
2127 assertTrue("Check entrySchema Property Type ",
2128 pro.getSchema().getProperty().getType().equals("boolean"));
2129 isPropertyAppear = true;
2131 case "my_boolean_array":
2132 assertTrue("Check Property Type ", pro.getType().equals("list"));
2133 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[true,false]"));
2134 assertTrue("Check entrySchema Property Type ",
2135 pro.getSchema().getProperty().getType().equals("boolean"));
2136 isPropertyAppear = true;
2138 case "duplicate_boolean_values":
2139 assertTrue("Check Property Type ", pro.getType().equals("list"));
2140 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[true,false,true]"));
2141 assertTrue("Check entrySchema Property Type ",
2142 pro.getSchema().getProperty().getType().equals("boolean"));
2143 isPropertyAppear = true;
2145 case "boolean_values_Insensitive":
2146 assertTrue("Check Property Type ", pro.getType().equals("list"));
2147 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[true,false,true]"));
2148 assertTrue("Check entrySchema Property Type ",
2149 pro.getSchema().getProperty().getType().equals("boolean"));
2150 isPropertyAppear = true;
2153 assertTrue("Check Property Type ", pro.getType().equals("list"));
2154 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[0,1000,-1000,50]"));
2155 assertTrue("Check entrySchema Property Type ",
2156 pro.getSchema().getProperty().getType().equals("integer"));
2157 isPropertyAppear = true;
2159 case "my_integers_array":
2160 assertTrue("Check Property Type ", pro.getType().equals("list"));
2161 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[10,-1000,0]"));
2162 assertTrue("Check entrySchema Property Type ",
2163 pro.getSchema().getProperty().getType().equals("integer"));
2164 isPropertyAppear = true;
2166 case "duplicate_integers_values":
2167 assertTrue("Check Property Type ", pro.getType().equals("list"));
2168 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[10,10,-1000,0]"));
2169 assertTrue("Check entrySchema Property Type ",
2170 pro.getSchema().getProperty().getType().equals("integer"));
2171 isPropertyAppear = true;
2174 assertTrue("Check Property Type ", pro.getType().equals("list"));
2175 assertTrue("Check Property default values ",
2176 pro.getDefaultValue().equals("[\"asdc\",\"$?^@ecomp$!#%()_-~@+*^...;;/w#\",\"uc\"]"));
2177 // assertTrue("Check Property default values ",
2178 // pro.getDefaultValue().equals("[\"asdc\",\"@=~!@#$%^&*()_+=?><:-w\",\"uc\"]"));
2179 assertTrue("Check entrySchema Property Type ",
2180 pro.getSchema().getProperty().getType().equals("string"));
2181 isPropertyAppear = true;
2183 case "my_string_array":
2184 assertTrue("Check Property Type ", pro.getType().equals("list"));
2185 assertTrue("Check Property default values ",
2186 pro.getDefaultValue().equals("[\"AAA\",\"~$~#bbb%^*_-\",\"qwe\",\"1.3\",\"500\",\"true\"]"));
2187 assertTrue("Check entrySchema Property Type ",
2188 pro.getSchema().getProperty().getType().equals("string"));
2189 isPropertyAppear = true;
2191 case "duplicate_string_values":
2192 assertTrue("Check Property Type ", pro.getType().equals("list"));
2193 assertTrue("Check Property default values ",
2194 pro.getDefaultValue().equals("[\"asdc\",\"asdc\",\"uc\"]"));
2195 assertTrue("Check entrySchema Property Type ",
2196 pro.getSchema().getProperty().getType().equals("string"));
2197 isPropertyAppear = true;
2199 case "string_null_value":
2200 assertTrue("Check Property Type ", pro.getType().equals("list"));
2201 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[\"asdc\",\"uc\"]"));
2202 assertTrue("Check entrySchema Property Type ",
2203 pro.getSchema().getProperty().getType().equals("string"));
2204 isPropertyAppear = true;
2206 case "string_space_value":
2207 assertTrue("Check Property Type ", pro.getType().equals("list"));
2208 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[\"asdc\",\"uc\"]"));
2209 assertTrue("Check entrySchema Property Type ",
2210 pro.getSchema().getProperty().getType().equals("string"));
2211 isPropertyAppear = true;
2213 case "string_array_null_value":
2214 assertTrue("Check Property Type ", pro.getType().equals("list"));
2215 assertTrue("Check Property default values ",
2216 pro.getDefaultValue().equals("[\"aaa\",\"bbb\",\"500\"]"));
2217 assertTrue("Check entrySchema Property Type ",
2218 pro.getSchema().getProperty().getType().equals("string"));
2219 isPropertyAppear = true;
2222 assertTrue("Check Property Type ", pro.getType().equals("list"));
2223 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[6,1000.000001,-3.0]"));
2224 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2225 isPropertyAppear = true;
2227 case "my_float_array":
2228 assertTrue("Check Property Type ", pro.getType().equals("list"));
2229 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[0.01,-5.0,2.1]"));
2230 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2231 isPropertyAppear = true;
2233 case "duplicate_float_values":
2234 assertTrue("Check Property Type ", pro.getType().equals("list"));
2235 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[0.0,0.0,4.555555]"));
2236 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2237 isPropertyAppear = true;
2239 case "float_no_default_values":
2240 assertTrue("Check Property Type ", pro.getType().equals("list"));
2241 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2242 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2243 isPropertyAppear = true;
2245 case "integer_no_default_values":
2246 assertTrue("Check Property Type ", pro.getType().equals("list"));
2247 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2248 assertTrue("Check entrySchema Property Type ",
2249 pro.getSchema().getProperty().getType().equals("integer"));
2250 isPropertyAppear = true;
2252 case "string_no_default_values":
2253 assertTrue("Check Property Type ", pro.getType().equals("list"));
2254 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2255 assertTrue("Check entrySchema Property Type ",
2256 pro.getSchema().getProperty().getType().equals("string"));
2257 isPropertyAppear = true;
2259 case "boolean_no_default_values":
2260 assertTrue("Check Property Type ", pro.getType().equals("list"));
2261 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2262 assertTrue("Check entrySchema Property Type ",
2263 pro.getSchema().getProperty().getType().equals("boolean"));
2264 isPropertyAppear = true;
2266 case "integer_null_value":
2267 assertTrue("Check Property Type ", pro.getType().equals("list"));
2268 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[1000,2000]"));
2269 assertTrue("Check entrySchema Property Type ",
2270 pro.getSchema().getProperty().getType().equals("integer"));
2271 isPropertyAppear = true;
2273 case "boolean_null_value":
2274 assertTrue("Check Property Type ", pro.getType().equals("list"));
2275 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[true,false]"));
2276 assertTrue("Check entrySchema Property Type ",
2277 pro.getSchema().getProperty().getType().equals("boolean"));
2278 isPropertyAppear = true;
2280 case "float_null_value":
2281 assertTrue("Check Property Type ", pro.getType().equals("list"));
2282 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[6,-3.0]"));
2283 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2284 isPropertyAppear = true;
2286 case "float_space_value":
2287 assertTrue("Check Property Type ", pro.getType().equals("list"));
2288 assertTrue("Check Property default values ", pro.getDefaultValue().equals("[6,-3.0]"));
2289 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2290 isPropertyAppear = true;
2294 assertTrue(isPropertyAppear);
2295 isPropertyAppear = false;
2300 private void verifyRequirementsOccurrences(Resource resourceJavaObject, String requirementsType) {
2301 boolean isRequirementAppear = false;
2302 // List<RequirementDefinition> requerments =
2303 // resourceJavaObject.getRequirements().get("tosca.capabilities.Attachment");
2304 List<RequirementDefinition> requerments = resourceJavaObject.getRequirements().get(requirementsType);
2306 for (RequirementDefinition req : requerments) {
2307 switch (req.getName()) {
2308 case "local_storage100":
2309 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2310 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("UNBOUNDED"));
2311 isRequirementAppear = true;
2313 case "local_storage200":
2314 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2315 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("1"));
2316 isRequirementAppear = true;
2318 case "local_storage300":
2319 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2320 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("10"));
2321 isRequirementAppear = true;
2323 case "local_storage400":
2324 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2325 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("10000000"));
2326 isRequirementAppear = true;
2328 case "local_storage500":
2329 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("2"));
2330 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("3"));
2331 isRequirementAppear = true;
2333 case "local_storageNoOccurrences600":
2334 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2335 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("1"));
2336 isRequirementAppear = true;
2339 assertTrue(isRequirementAppear);
2340 isRequirementAppear = false;
2345 private void verifyCapabilitiesOccurrences(Resource resourceJavaObject, String capabilitType) {
2346 boolean isCapabilityAppear = false;
2347 // List<CapabilityDefinition> capabilities =
2348 // resourceJavaObject.getCapabilities().get("tosca.capabilities.Endpoint.Admin");
2349 List<CapabilityDefinition> capabilities = resourceJavaObject.getCapabilities().get(capabilitType);
2351 for (CapabilityDefinition cap : capabilities) {
2352 switch (cap.getName()) {
2353 case "endpointNoOccurrence":
2354 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2355 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("UNBOUNDED"));
2356 isCapabilityAppear = true;
2359 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2360 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("2"));
2361 isCapabilityAppear = true;
2364 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2365 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("1"));
2366 isCapabilityAppear = true;
2369 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2370 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("10"));
2371 isCapabilityAppear = true;
2374 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2375 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("10000000"));
2376 isCapabilityAppear = true;
2379 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2380 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("UNBOUNDED"));
2381 isCapabilityAppear = true;
2384 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("2"));
2385 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("4"));
2386 isCapabilityAppear = true;
2390 assertTrue(isCapabilityAppear);
2391 isCapabilityAppear = false;
2396 private void verifyResourcePropertiesMap(Resource resourceJavaObject) { // use
2397 // importMapPropertySuccessFlow.yml
2398 boolean isPropertyAppear = false;
2399 List<PropertyDefinition> propertiesList = resourceJavaObject.getProperties();
2400 for (PropertyDefinition pro : propertiesList) {
2401 switch (pro.getName()) {
2402 case "string_prop01":
2403 assertTrue("Check Property Type ", pro.getType().equals("map"));
2404 assertTrue("Check Property default values ",
2405 pro.getDefaultValue().equals("{\"keyA\":\"val1\",\"keyB\":\"val2\"}"));
2406 assertTrue("Check entrySchema Property Type ",
2407 pro.getSchema().getProperty().getType().equals("string"));
2408 isPropertyAppear = true;
2410 case "string_prop02":
2411 assertTrue("Check Property Type ", pro.getType().equals("map"));
2412 assertTrue("Check Property default values ",
2413 pro.getDefaultValue().equals("{\"keyA\":\"val1\",\"keyB\":\"val2\"}"));
2414 assertTrue("Check entrySchema Property Type ",
2415 pro.getSchema().getProperty().getType().equals("string"));
2416 isPropertyAppear = true;
2418 case "string_prop03":
2419 assertTrue("Check Property Type ", pro.getType().equals("map"));
2420 assertTrue("Check Property default values ",
2421 pro.getDefaultValue().equals("{\"keyA\":\"val1\",\"keyB\":\"val2\"}"));
2422 assertTrue("Check entrySchema Property Type ",
2423 pro.getSchema().getProperty().getType().equals("string"));
2424 isPropertyAppear = true;
2426 case "string_prop04":
2427 assertTrue("Check Property Type ", pro.getType().equals("map"));
2428 assertTrue("Check Property default values ",
2429 pro.getDefaultValue().equals("{\"keyA\":\"10\",\"keyB\":\"true\"}"));
2430 assertTrue("Check entrySchema Property Type ",
2431 pro.getSchema().getProperty().getType().equals("string"));
2432 isPropertyAppear = true;
2434 case "string_prop05":
2435 assertTrue("Check Property Type ", pro.getType().equals("map"));
2436 assertTrue("Check Property default values ",
2437 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":\"Big\"}"));
2438 assertTrue("Check entrySchema Property Type ",
2439 pro.getSchema().getProperty().getType().equals("string"));
2440 isPropertyAppear = true;
2442 case "string_prop06":
2443 assertTrue("Check Property Type ", pro.getType().equals("map"));
2444 assertTrue("Check Property default values ",
2445 pro.getDefaultValue().equals("{\"keyA\":\"aaaA\",\"keyB\":null}"));
2446 assertTrue("Check entrySchema Property Type ",
2447 pro.getSchema().getProperty().getType().equals("string"));
2448 isPropertyAppear = true;
2450 case "string_prop07":
2451 assertTrue("Check Property Type ", pro.getType().equals("map"));
2452 assertTrue("Check Property default values ",
2453 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null}"));
2454 assertTrue("Check entrySchema Property Type ",
2455 pro.getSchema().getProperty().getType().equals("string"));
2456 isPropertyAppear = true;
2458 case "string_prop08":
2459 assertTrue("Check Property Type ", pro.getType().equals("map"));
2460 assertTrue("Check Property default values ",
2461 pro.getDefaultValue().equals("{\"keyA\":\"\",\"keyB\":\"abcd\"}"));
2462 assertTrue("Check entrySchema Property Type ",
2463 pro.getSchema().getProperty().getType().equals("string"));
2464 isPropertyAppear = true;
2466 case "string_prop09":
2467 assertTrue("Check Property Type ", pro.getType().equals("map"));
2468 assertTrue("Check Property default values ",
2469 pro.getDefaultValue().equals("{\"keyA\":\" \",\"keyB\":\"abcd\"}"));
2470 assertTrue("Check entrySchema Property Type ",
2471 pro.getSchema().getProperty().getType().equals("string"));
2472 isPropertyAppear = true;
2474 case "string_prop10":
2475 assertTrue("Check Property Type ", pro.getType().equals("map"));
2476 assertTrue("Check Property default values ",
2477 pro.getDefaultValue().equals("{\"keyA\":\" aaaa\",\"keyB\":\" bbbb\"}"));
2478 assertTrue("Check entrySchema Property Type ",
2479 pro.getSchema().getProperty().getType().equals("string"));
2480 isPropertyAppear = true;
2482 case "string_prop11":
2483 assertTrue("Check Property Type ", pro.getType().equals("map"));
2484 assertTrue("Check Property default values ",
2485 pro.getDefaultValue().equals("{\"keyA\":\"aaaa \",\"keyB\":\"bbbb \"}"));
2486 assertTrue("Check entrySchema Property Type ",
2487 pro.getSchema().getProperty().getType().equals("string"));
2488 isPropertyAppear = true;
2490 case "string_prop12":
2491 assertTrue("Check Property Type ", pro.getType().equals("map"));
2492 assertTrue("Check Property default values ",
2493 pro.getDefaultValue().equals("{\"keyA\":\" aaaa \",\"keyB\":\" bbbb ccccc \"}"));
2494 assertTrue("Check entrySchema Property Type ",
2495 pro.getSchema().getProperty().getType().equals("string"));
2496 isPropertyAppear = true;
2498 case "string_prop13":
2499 assertTrue("Check Property Type ", pro.getType().equals("map"));
2500 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\"aaaa\"}"));
2501 assertTrue("Check entrySchema Property Type ",
2502 pro.getSchema().getProperty().getType().equals("string"));
2503 isPropertyAppear = true;
2505 case "string_prop14":
2506 assertTrue("Check Property Type ", pro.getType().equals("map"));
2507 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\" aaaa \"}"));
2508 assertTrue("Check entrySchema Property Type ",
2509 pro.getSchema().getProperty().getType().equals("string"));
2510 isPropertyAppear = true;
2512 case "string_prop15":
2513 assertTrue("Check Property Type ", pro.getType().equals("map"));
2514 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2515 assertTrue("Check entrySchema Property Type ",
2516 pro.getSchema().getProperty().getType().equals("string"));
2517 isPropertyAppear = true;
2519 case "string_prop16":
2520 assertTrue("Check Property Type ", pro.getType().equals("map"));
2521 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2522 assertTrue("Check entrySchema Property Type ",
2523 pro.getSchema().getProperty().getType().equals("string"));
2524 isPropertyAppear = true;
2526 case "string_prop17":
2527 assertTrue("Check Property Type ", pro.getType().equals("map"));
2528 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2529 assertTrue("Check entrySchema Property Type ",
2530 pro.getSchema().getProperty().getType().equals("string"));
2531 isPropertyAppear = true;
2533 case "string_prop18":
2534 assertTrue("Check Property Type ", pro.getType().equals("map"));
2535 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2536 assertTrue("Check entrySchema Property Type ",
2537 pro.getSchema().getProperty().getType().equals("string"));
2538 isPropertyAppear = true;
2540 case "string_prop19":
2541 assertTrue("Check Property Type ", pro.getType().equals("map"));
2542 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2543 assertTrue("Check entrySchema Property Type ",
2544 pro.getSchema().getProperty().getType().equals("string"));
2545 isPropertyAppear = true;
2547 case "string_prop20":
2548 assertTrue("Check Property Type ", pro.getType().equals("map"));
2549 assertTrue("Check Property default values ", pro.getDefaultValue()
2550 .equals("{\"keyA\":\"aaaa\",\"keya\":\"aaaa\",\"Keya\":\"Aaaa\",\"KEYA\":\"nnnn\"}"));
2551 assertTrue("Check entrySchema Property Type ",
2552 pro.getSchema().getProperty().getType().equals("string"));
2553 isPropertyAppear = true;
2555 case "string_prop21":
2556 assertTrue("Check Property Type ", pro.getType().equals("map"));
2557 assertTrue("Check Property default values ",
2558 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null}"));
2559 assertTrue("Check entrySchema Property Type ",
2560 pro.getSchema().getProperty().getType().equals("string"));
2561 isPropertyAppear = true;
2563 case "string_prop22":
2564 assertTrue("Check Property Type ", pro.getType().equals("map"));
2565 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2566 assertTrue("Check entrySchema Property Type ",
2567 pro.getSchema().getProperty().getType().equals("string"));
2568 isPropertyAppear = true;
2570 case "integer_prop01":
2571 assertTrue("Check Property Type ", pro.getType().equals("map"));
2572 assertTrue("Check Property default values ",
2573 pro.getDefaultValue().equals("{\"keyA\":1,\"keyB\":1000}"));
2574 assertTrue("Check entrySchema Property Type ",
2575 pro.getSchema().getProperty().getType().equals("integer"));
2576 isPropertyAppear = true;
2578 case "integer_prop02":
2579 assertTrue("Check Property Type ", pro.getType().equals("map"));
2580 assertTrue("Check Property default values ",
2581 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null}"));
2582 assertTrue("Check entrySchema Property Type ",
2583 pro.getSchema().getProperty().getType().equals("integer"));
2584 isPropertyAppear = true;
2586 case "integer_prop03":
2587 assertTrue("Check Property Type ", pro.getType().equals("map"));
2588 assertTrue("Check Property default values ",
2589 pro.getDefaultValue().equals("{\"keyA\":800,\"keyB\":-600}"));
2590 assertTrue("Check entrySchema Property Type ",
2591 pro.getSchema().getProperty().getType().equals("integer"));
2592 isPropertyAppear = true;
2594 case "integer_prop04":
2595 assertTrue("Check Property Type ", pro.getType().equals("map"));
2596 assertTrue("Check Property default values ",
2597 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":-600}"));
2598 assertTrue("Check entrySchema Property Type ",
2599 pro.getSchema().getProperty().getType().equals("integer"));
2600 isPropertyAppear = true;
2602 case "integer_prop05":
2603 assertTrue("Check Property Type ", pro.getType().equals("map"));
2604 assertTrue("Check Property default values ",
2605 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":0}"));
2606 assertTrue("Check entrySchema Property Type ",
2607 pro.getSchema().getProperty().getType().equals("integer"));
2608 isPropertyAppear = true;
2610 case "integer_prop06":
2611 assertTrue("Check Property Type ", pro.getType().equals("map"));
2612 assertTrue("Check Property default values ",
2613 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":0}"));
2614 assertTrue("Check entrySchema Property Type ",
2615 pro.getSchema().getProperty().getType().equals("integer"));
2616 isPropertyAppear = true;
2618 case "integer_prop07":
2619 assertTrue("Check Property Type ", pro.getType().equals("map"));
2620 assertTrue("Check Property default values ",
2621 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":100}"));
2622 assertTrue("Check entrySchema Property Type ",
2623 pro.getSchema().getProperty().getType().equals("integer"));
2624 isPropertyAppear = true;
2626 case "integer_prop08":
2627 assertTrue("Check Property Type ", pro.getType().equals("map"));
2628 assertTrue("Check Property default values ",
2629 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":200}"));
2630 assertTrue("Check entrySchema Property Type ",
2631 pro.getSchema().getProperty().getType().equals("integer"));
2632 isPropertyAppear = true;
2634 case "integer_prop09":
2635 assertTrue("Check Property Type ", pro.getType().equals("map"));
2636 assertTrue("Check Property default values ",
2637 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":200}"));
2638 assertTrue("Check entrySchema Property Type ",
2639 pro.getSchema().getProperty().getType().equals("integer"));
2640 isPropertyAppear = true;
2642 case "integer_prop10":
2643 assertTrue("Check Property Type ", pro.getType().equals("map"));
2644 assertTrue("Check Property default values ",
2645 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":2222}"));
2646 assertTrue("Check entrySchema Property Type ",
2647 pro.getSchema().getProperty().getType().equals("integer"));
2648 isPropertyAppear = true;
2650 case "integer_prop11":
2651 assertTrue("Check Property Type ", pro.getType().equals("map"));
2652 assertTrue("Check Property default values ",
2653 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2654 assertTrue("Check entrySchema Property Type ",
2655 pro.getSchema().getProperty().getType().equals("integer"));
2656 isPropertyAppear = true;
2658 case "integer_prop12":
2659 assertTrue("Check Property Type ", pro.getType().equals("map"));
2660 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2661 assertTrue("Check entrySchema Property Type ",
2662 pro.getSchema().getProperty().getType().equals("integer"));
2663 isPropertyAppear = true;
2665 case "integer_prop13":
2666 assertTrue("Check Property Type ", pro.getType().equals("map"));
2667 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":200}"));
2668 assertTrue("Check entrySchema Property Type ",
2669 pro.getSchema().getProperty().getType().equals("integer"));
2670 isPropertyAppear = true;
2672 case "boolean_prop01":
2673 assertTrue("Check Property Type ", pro.getType().equals("map"));
2674 assertTrue("Check Property default values ",
2675 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false,\"keyC\":false}"));
2676 assertTrue("Check entrySchema Property Type ",
2677 pro.getSchema().getProperty().getType().equals("boolean"));
2678 isPropertyAppear = true;
2680 case "boolean_prop02":
2681 assertTrue("Check Property Type ", pro.getType().equals("map"));
2682 assertTrue("Check Property default values ",
2683 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false,\"keyC\":false}"));
2684 assertTrue("Check entrySchema Property Type ",
2685 pro.getSchema().getProperty().getType().equals("boolean"));
2686 isPropertyAppear = true;
2688 case "boolean_prop03":
2689 assertTrue("Check Property Type ", pro.getType().equals("map"));
2690 assertTrue("Check Property default values ",
2691 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2692 assertTrue("Check entrySchema Property Type ",
2693 pro.getSchema().getProperty().getType().equals("boolean"));
2694 isPropertyAppear = true;
2696 case "boolean_prop04":
2697 assertTrue("Check Property Type ", pro.getType().equals("map"));
2698 assertTrue("Check Property default values ",
2699 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2700 assertTrue("Check entrySchema Property Type ",
2701 pro.getSchema().getProperty().getType().equals("boolean"));
2702 isPropertyAppear = true;
2704 case "boolean_prop05":
2705 assertTrue("Check Property Type ", pro.getType().equals("map"));
2706 assertTrue("Check Property default values ",
2707 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false,\"keyC\":false}"));
2708 assertTrue("Check entrySchema Property Type ",
2709 pro.getSchema().getProperty().getType().equals("boolean"));
2710 isPropertyAppear = true;
2712 case "boolean_prop06":
2713 assertTrue("Check Property Type ", pro.getType().equals("map"));
2714 assertTrue("Check Property default values ",
2715 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":true,\"keyC\":false}"));
2716 assertTrue("Check entrySchema Property Type ",
2717 pro.getSchema().getProperty().getType().equals("boolean"));
2718 isPropertyAppear = true;
2720 case "boolean_prop07":
2721 assertTrue("Check Property Type ", pro.getType().equals("map"));
2722 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2723 assertTrue("Check entrySchema Property Type ",
2724 pro.getSchema().getProperty().getType().equals("boolean"));
2725 isPropertyAppear = true;
2727 case "boolean_prop08":
2728 assertTrue("Check Property Type ", pro.getType().equals("map"));
2729 assertTrue("Check Property default values ",
2730 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false}"));
2731 assertTrue("Check entrySchema Property Type ",
2732 pro.getSchema().getProperty().getType().equals("boolean"));
2733 isPropertyAppear = true;
2735 case "boolean_prop09":
2736 assertTrue("Check Property Type ", pro.getType().equals("map"));
2737 assertTrue("Check Property default values ",
2738 pro.getDefaultValue().equals("{\"keyA\":false,\"keyB\":true}"));
2739 assertTrue("Check entrySchema Property Type ",
2740 pro.getSchema().getProperty().getType().equals("boolean"));
2741 isPropertyAppear = true;
2743 case "float_prop01":
2744 assertTrue("Check Property Type ", pro.getType().equals("map"));
2745 assertTrue("Check Property default values ",
2746 pro.getDefaultValue().equals("{\"keyA\":1.2,\"keyB\":3.56,\"keyC\":33}"));
2747 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2748 isPropertyAppear = true;
2750 case "float_prop02":
2751 assertTrue("Check Property Type ", pro.getType().equals("map"));
2752 assertTrue("Check Property default values ",
2753 pro.getDefaultValue().equals("{\"keyA\":0.0,\"keyB\":0.0,\"keyC\":0}"));
2754 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2755 isPropertyAppear = true;
2757 case "float_prop03":
2758 assertTrue("Check Property Type ", pro.getType().equals("map"));
2759 assertTrue("Check Property default values ",
2760 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2761 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2762 isPropertyAppear = true;
2764 case "float_prop04":
2765 assertTrue("Check Property Type ", pro.getType().equals("map"));
2766 assertTrue("Check Property default values ",
2767 pro.getDefaultValue().equals("{\"keyA\":1.2,\"keyB\":3.56,\"keyC\":33}"));
2768 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2769 isPropertyAppear = true;
2771 case "float_prop05":
2772 assertTrue("Check Property Type ", pro.getType().equals("map"));
2773 assertTrue("Check Property default values ",
2774 pro.getDefaultValue().equals("{\"keyA\":33,\"keyB\":1.2,\"keyC\":3.607,\"keyD\":0}"));
2775 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2776 isPropertyAppear = true;
2778 case "float_prop06":
2779 assertTrue("Check Property Type ", pro.getType().equals("map"));
2780 assertTrue("Check Property default values ",
2781 pro.getDefaultValue().equals("{\"keyA\":33,\"keyB\":1.2,\"keyC\":3.607}"));
2782 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2783 isPropertyAppear = true;
2785 case "float_prop07":
2786 assertTrue("Check Property Type ", pro.getType().equals("map"));
2787 assertTrue("Check Property default values ",
2788 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2789 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2790 isPropertyAppear = true;
2792 case "float_prop08":
2793 assertTrue("Check Property Type ", pro.getType().equals("map"));
2794 assertEquals("Check Property default values ", pro.getDefaultValue(), null);
2795 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2796 isPropertyAppear = true;
2798 case "float_prop09":
2799 assertTrue("Check Property Type ", pro.getType().equals("map"));
2800 assertTrue("Check Property default values ",
2801 pro.getDefaultValue().equals("{\"keyA\":0.01,\"keyB\":null}"));
2802 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2803 isPropertyAppear = true;
2805 case "float_prop10":
2806 assertTrue("Check Property Type ", pro.getType().equals("map"));
2807 assertTrue("Check Property default values ", pro.getDefaultValue().equals("{\"keyA\":0.00020}"));
2808 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2809 isPropertyAppear = true;
2811 case "float_prop11":
2812 assertTrue("Check Property Type ", pro.getType().equals("map"));
2813 assertTrue("Check Property default values ",
2814 pro.getDefaultValue().equals("{\"keyA\":3.56,\"keyB\":33}"));
2815 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2816 isPropertyAppear = true;
2819 assertTrue(isPropertyAppear);
2820 isPropertyAppear = false;
2826 public void importToscaResourceAttributeSuccessFlow() throws Exception {
2828 String fileName = importAttributeSuccess;
2829 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
2831 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
2833 ResourceRestUtils.checkCreateResponse(importResourceResponse);
2834 Resource resourceJavaObject = ResponseParser
2835 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
2836 ToscaNodeTypeInfo parseToscaNodeYaml = utils
2837 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
2839 HashMap<String, PropertyDefinition> attr = new HashMap<>();
2841 PropertyDefinition newAttr2 = new PropertyDefinition();
2842 newAttr2.setName("networks");
2843 newAttr2.setType("map");
2844 newAttr2.setDefaultValue("{\"keyA\" : val1 , \"keyB\" : val2}");
2845 SchemaDefinition schema = new SchemaDefinition();
2846 PropertyDataDefinition prop = new PropertyDataDefinition();
2847 prop.setType("string");
2848 schema.setProperty(prop);
2849 newAttr2.setSchema(schema);
2850 attr.put("networks", newAttr2);
2852 PropertyDefinition newAttr1 = new PropertyDefinition();
2853 newAttr1.setName("public_address");
2854 newAttr1.setType("string");
2855 attr.put("public_address", newAttr1);
2857 PropertyDefinition newAttr3 = new PropertyDefinition();
2858 newAttr3.setName("ports");
2859 newAttr3.setDescription("this is my description");
2860 attr.put("ports", newAttr3);
2862 PropertyDefinition newAttr = new PropertyDefinition();
2863 newAttr.setDefaultValue("myDefault");
2864 newAttr.setName("private_address");
2865 newAttr.setStatus("supported");
2866 newAttr.setType("string");
2867 attr.put("private_address", newAttr);
2869 // verify Resource Attributes
2870 validateResourceAttribute(resourceJavaObject, attr);
2873 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
2874 .getDefaultImportResourceAuditMsgSuccess();
2875 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
2876 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
2877 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
2878 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
2879 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
2880 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
2883 private void validateResourceAttribute(Resource resource, Map<String, PropertyDefinition> attr) {
2884 List<PropertyDefinition> resList = resource.getAttributes();
2885 int size = resList.size();
2886 String attributeName;
2887 for (int i = 0; i < size; i++) {
2888 attributeName = resList.get(i).getName();
2889 assertEquals(attr.get(attributeName).getDefaultValue(), resList.get(i).getDefaultValue());
2890 assertEquals(attr.get(attributeName).getName(), resList.get(i).getName());
2891 assertEquals(attr.get(attributeName).getDescription(), resList.get(i).getDescription());
2892 assertEquals(attr.get(attributeName).getStatus(), resList.get(i).getStatus());