asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportToscaResourceTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.imports;
  22
  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;
  30
  31 import java.io.File;
  32 import java.io.IOException;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.HashMap;
  36 import java.util.Iterator;
  37 import java.util.List;
  38 import java.util.Map;
  39
  40 import org.apache.http.client.ClientProtocolException;
  41 import org.junit.Rule;
  42 import org.junit.rules.TestName;
  43 import org.openecomp.sdc.be.dao.api.ActionStatus;
  44 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  46 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  48 import org.openecomp.sdc.be.model.CapReqDef;
  49 import org.openecomp.sdc.be.model.CapabilityDefinition;
  50 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  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.RelationshipInfo;
  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;
  96
  97 /**
  98  *
  99  * @author Andrey + Pavel + Shay
 100  *
 101  */
 102
 103 public class ImportToscaResourceTest extends ComponentBaseTest {
 104         private static Logger logger = LoggerFactory.getLogger(ImportToscaResourceTest.class.getName());
 105         protected Utils utils = new Utils();
 106
 107         public ImportToscaResourceTest() {
 108                 super(name, ImportToscaResourceTest.class.getName());
 109         }
 110
 111         public ImportReqDetails importReqDetails;
 112         protected static User sdncUserDetails;
 113         protected static User testerUser;
 114         protected String testResourcesPath;
 115         protected ResourceReqDetails resourceDetails;
 116         private int actualNumOfReqOrCap;
 117
 118         @Rule
 119         public static TestName name = new TestName();
 120
 121         @BeforeMethod
 122         public void before() throws Exception {
 123                 importReqDetails = ElementFactory.getDefaultImportResource();
 124                 sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 125                 testerUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 126                 resourceDetails = ElementFactory.getDefaultResource();
 127                 String sourceDir = config.getResourceConfigDir();
 128                 final String workDir = "importToscaResourceByCreateUrl";
 129                 testResourcesPath = sourceDir + File.separator + workDir;
 130                 actualNumOfReqOrCap = 0;
 131         }
 132
 133         @DataProvider
 134         private static final Object[][] getYmlWithInValidListProperties() throws IOException, Exception {
 135                 return new Object[][] { { "ListPropertyFalure02.yml", "[false,\"truee\"]", "boolean" },
 136                                 { "ListPropertyFalure03.yml", "[false,3]", "boolean" },
 137                                 { "ListPropertyFalure04.yml", "[false,3.56]", "boolean" },
 138                                 { "ListPropertyFalure05.yml", "[10000,3.56]", "integer" },
 139                                 { "ListPropertyFalure06.yml", "[10000,\"aaaa\"]", "integer" },
 140                                 { "ListPropertyFalure07.yml", "[10000,true]", "integer" },
 141                                 { "ListPropertyFalure08.yml", "[10.5,true]", "float" },
 142                                 { "ListPropertyFalure09.yml", "[10.5,\"asdc\"]", "float" }, // type
 143                                                                                                                                                         // float
 144                                 { "ListPropertyFalure11.yml", "[10.5,\"500.0@\"]", "float" }, // property
 145                                                                                                                                                                 // list
 146                                                                                                                                                                 // float
 147                                                                                                                                                                 // type
 148                                                                                                                                                                 // contain
 149                                                                                                                                                                 // @
 150                                                                                                                                                                 // in
 151                                                                                                                                                                 // default
 152                                                                                                                                                                 // value
 153                                 { "ListPropertyFalure12.yml", "[10000,\"3#\"]", "integer" }, // property
 154                                                                                                                                                                 // list
 155                                                                                                                                                                 // integer
 156                                                                                                                                                                 // type
 157                                                                                                                                                                 // contain
 158                                                                                                                                                                 // #
 159                                                                                                                                                                 // in
 160                                                                                                                                                                 // default
 161                                                                                                                                                                 // value
 162                                 { "ListPropertyFalure13.yml", "[false,\"true%\"]", "boolean" }, // property
 163                                                                                                                                                                 // list
 164                                                                                                                                                                 // boolean
 165                                                                                                                                                                 // type
 166                                                                                                                                                                 // contain
 167                                                                                                                                                                 // %
 168                                                                                                                                                                 // in
 169                                                                                                                                                                 // default
 170                                                                                                                                                                 // value
 171                                 { "ListPropertyFalure14.yml", "[false,\"falsee\",true]", "boolean" },
 172                                 { "ListPropertyFalure15.yml", "[10.5,\"10.6x\",20.5,30.5]", "float" } // float
 173                                                                                                                                                                                 // with
 174                                                                                                                                                                                 // value
 175                                                                                                                                                                                 // 10.6x
 176                                                                                                                                                                                 // instead
 177                                                                                                                                                                                 // 10.6f
 178
 179                 };
 180         }
 181
 182         @DataProvider
 183         private static final Object[][] getYmlWithInValidMapProperties() throws IOException, Exception {
 184                 return new Object[][] { { "MapPropertyFalure02.yml", "[false,\"truee\"]", "boolean" },
 185                                 { "MapPropertyFalure03.yml", "[false,3]", "boolean" },
 186                                 { "MapPropertyFalure04.yml", "[false,3.56]", "boolean" },
 187                                 { "MapPropertyFalure05.yml", "[10000,3.56]", "integer" },
 188                                 { "MapPropertyFalure06.yml", "[10000,\"aaaa\"]", "integer" },
 189                                 { "MapPropertyFalure07.yml", "[10000,true]", "integer" },
 190                                 { "MapPropertyFalure08.yml", "[10.5,true]", "float" },
 191                                 { "MapPropertyFalure09.yml", "[10.5,\"asdc\"]", "float" }, // type
 192                                                                                                                                                         // float
 193                                 { "MapPropertyFalure11.yml", "[10.5,\"500.0@\"]", "float" }, // property
 194                                                                                                                                                                 // list
 195                                                                                                                                                                 // float
 196                                                                                                                                                                 // type
 197                                                                                                                                                                 // contain
 198                                                                                                                                                                 // @
 199                                                                                                                                                                 // in
 200                                                                                                                                                                 // default
 201                                                                                                                                                                 // value
 202                                 { "MapPropertyFalure12.yml", "[10000,\"3#\"]", "integer" }, // property
 203                                                                                                                                                         // list
 204                                                                                                                                                         // integer
 205                                                                                                                                                         // type
 206                                                                                                                                                         // contain
 207                                                                                                                                                         // #
 208                                                                                                                                                         // in
 209                                                                                                                                                         // default
 210                                                                                                                                                         // value
 211                                 { "MapPropertyFalure13.yml", "[false,\"true%\"]", "boolean" }, // property
 212                                                                                                                                                                 // list
 213                                                                                                                                                                 // boolean
 214                                                                                                                                                                 // type
 215                                                                                                                                                                 // contain
 216                                                                                                                                                                 // %
 217                                                                                                                                                                 // in
 218                                                                                                                                                                 // default
 219                                                                                                                                                                 // value
 220                                 { "MapPropertyFalure14.yml", "[false,\"falsee\",true]", "boolean" },
 221                                 { "MapPropertyFalure15.yml", "[10.5,\"10.6x\",20.5,30.5]", "float" } // float
 222                                                                                                                                                                                 // with
 223                                                                                                                                                                                 // value
 224                                                                                                                                                                                 // 10.6x
 225                                                                                                                                                                                 // instead
 226                                                                                                                                                                                 // 10.6f
 227
 228                 };
 229         }
 230
 231         @DataProvider
 232         private static final Object[][] getYmlWithInValidOccurrences() throws IOException, Exception {
 233                 return new Object[][] { { "occurencyFalure01.yml" }, // requirements [2
 234                                                                                                                                 // , 0]
 235                                 { "occurencyFalure02.yml" }, // requirements [-1, 2]
 236                                 { "occurencyFalure03.yml" }, // requirements [1 ,-2]
 237                                 { "occurencyFalure05.yml" }, // requirements MAX occurrences not
 238                                                                                                 // exist [ 1 , ]
 239                                 { "occurencyFalure06.yml" }, // requirements [ 0 , 0 ]
 240                                 { "occurencyFalure08.yml" }, // requirements [ 1.0 , 2.0 ]
 241                                 { "occurencyFalure09.yml" }, // requirements [ "1" , "2" ]
 242                                 { "occurencyFalure10.yml" }, // requirements [ ]
 243                                 { "occurencyFalure11.yml" }, // requirements [ UNBOUNDED ,
 244                                                                                                 // UNBOUNDED ]
 245                                 { "occurencyFalure31.yml" }, // capability [ 2, 1]
 246                                 { "occurencyFalure32.yml" }, // capability [-1, 2]
 247                                 { "occurencyFalure33.yml" }, // capability [1, -2]
 248                                 { "occurencyFalure35.yml" }, // capability MAX occurrences not
 249                                                                                                 // exist [ 1 , ]
 250                                 { "occurencyFalure36.yml" }, // capability [ 0 , 0 ]
 251                                 { "occurencyFalure38.yml" }, // capability [ 1.0 , 2.0 ]
 252                                 { "occurencyFalure39.yml" }, // capability [ "1" , "2" ]
 253                                 { "occurencyFalure40.yml" }, // capability [ ]
 254                                 { "occurencyFalure41.yml" } // capability [ UNBOUNDED ,
 255                                                                                         // UNBOUNDED ]
 256                 };
 257         }
 258
 259         @DataProvider
 260         private static final Object[][] getInvalidYmlWithOccurrences() throws IOException, Exception {
 261                 return new Object[][] { { "occurencyFalure04.yml" }, // requirements MIN
 262                                                                                                                                 // occurrences
 263                                                                                                                                 // not exist [ ,
 264                                                                                                                                 // 1]
 265                                 { "occurencyFalure07.yml" }, // requirements [ @ , 1 ]
 266                                 { "occurencyFalure34.yml" }, // capability MIN occurrences not
 267                                                                                                 // exist [ , 1]
 268                                 { "occurencyFalure37.yml" } // capability [ 0 , # ]
 269
 270                 };
 271         }
 272
 273         // US656928
 274         protected final String importMapPropertySuccess = "importMapPropertySuccessFlow.yml";
 275         protected final String importAttributeSuccess = "importAttributeSuccessFlow.yml";
 276         protected final String importSuccessFile = "myCompute.yml";
 277         protected final String derivedFromMyCompute = "derivedFromMyCompute.yml";
 278         protected final String importSuccessVFFile = "myComputeVF.yml";
 279         protected final String importNoDerivedFromFile = "myComputeDerivedFromNotExists.yml";
 280         protected final String importInvalidDefinitionVersionFile = "myComputeIncorrectDefenitionVersionValue.yml";
 281         protected final String importIncorrectNameSpaceFormatFile = "myComputeIncorrectNameSpaceFormat.yml";
 282         protected final String importNoDefenitionVersionFile = "myComputeNoDefenitionVersion.yml";
 283         protected final String importNodeTypesTwiceFile = "myComputeWithNodeTypesTwice.yml";
 284         protected final String importTopologyTemplateFile = "myComputeWithTopologyTemplate.yml";
 285         protected final String importNoContentFile = "noContent.yml";
 286         protected final String importWithOccurrences = "myComputeOccurencySuccess.yml";
 287         protected final String importListPropertyBadDefault = "importListPropertyBadDefault.yml";
 288         protected final String importListPropertyGoodDefault = "importListPropertyGoodDefault.yml";
 289         protected final String importListPropertySuccess = "importListPropertySuccessFlow.yml";
 290         // US631462
 291         protected final String importDuplicateRequirements = "importDuplicateRequirements.yml";
 292         protected final String importDuplicateCapability = "importDuplicateCapability.yml";
 293         protected final String importCapabilityNameExistsOnParent = "importCapabilityNameExistsOnParent.yml";
 294         protected final String importRequirementNameExistsOnParent = "importRequirementNameExistsOnParent.yml";
 295         protected final String importToscaResourceReqCapDerivedFromParent = "derivedFromWebAppDerivedReqCap.yml";
 296         protected final String missingCapInReqDef = "missingCapInReqDefinition.yml";
 297         protected final String missingCapInCapDef = "missingCapInCapDefinition.yml";
 298
 299         // US558432 - Support for Capability/Requirement "occurences" Import
 300         @Test(dataProvider = "getYmlWithInValidOccurrences")
 301         public void importToscaResourceWithOccurrencesFailuresFlow01(String ymlFileWithInvalidCapReqOccurrences)
 302                         throws Exception {
 303                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 304                                 ymlFileWithInvalidCapReqOccurrences);
 305                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 306                                 null);
 307                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
 308                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_OCCURRENCES.name(), new ArrayList<String>(),
 309                                 importResourceResponse.getResponse());
 310         }
 311
 312         @Test(dataProvider = "getInvalidYmlWithOccurrences")
 313         public void importToscaResourceWithOccurrencesFailuresFlow02(String ymlFileWithInvalidCapReqOccurrences)
 314                         throws Exception {
 315                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 316                                 ymlFileWithInvalidCapReqOccurrences);
 317                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 318                                 null);
 319                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
 320                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_YAML_FILE.name(), new ArrayList<String>(),
 321                                 importResourceResponse.getResponse());
 322         }
 323
 324         @Test
 325         public void importToscaResource() throws Exception {
 326
 327                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 328                                 importSuccessFile);
 329                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 330                                 null);
 331                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 332                 AssertJUnit.assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 333                                 importResourceResponse.getErrorCode() == 201);
 334                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 335                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 336                 Resource resourceJavaObject = ResponseParser
 337                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 338                 AssertJUnit.assertTrue("validate toscaResourceName field",
 339                                 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
 340                 AssertJUnit.assertTrue("validate resourceType field",
 341                                 resourceJavaObject.getResourceType().equals(ResourceTypeEnum.VFC));
 342                 // find derived from resource details
 343                 // Validate resource details after import-create resource including
 344                 // capabilities, interfaces from derived_from resource
 345
 346                 // Validate audit message
 347                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 348                                 .getDefaultImportResourceAuditMsgSuccess();
 349                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 350                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 351                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 352                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 353                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 354                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 355         }
 356
 357         @Test
 358         public void importToscaResourceWithOccurrencesSuccessFlow() throws Exception {
 359
 360                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 361                                 importWithOccurrences);
 362                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 363                                 null);
 364                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 365                 AssertJUnit.assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 366                                 importResourceResponse.getErrorCode() == 201);
 367                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 368                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 369                 Resource resourceJavaObject = ResponseParser
 370                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 371                 AssertJUnit.assertTrue("validate toscaResourceName field",
 372                                 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
 373                 AssertJUnit.assertTrue("validate resourceType field",
 374                                 resourceJavaObject.getResourceType().equals(ResourceTypeEnum.VFC));
 375                 String requirementsType = "tosca.capabilities.Attachment";
 376                 String capabilitType = "tosca.capabilities.Endpoint.Admin";
 377                 // Verify Occurrences of requirements and capabilities in resource
 378                 verifyRequirementsOccurrences(resourceJavaObject, requirementsType);
 379                 verifyCapabilitiesOccurrences(resourceJavaObject, capabilitType);
 380                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 381                                 .getDefaultImportResourceAuditMsgSuccess();
 382                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 383                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 384                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 385                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 386                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 387                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 388         }
 389
 390         // ------------------------------Success---------------------------------
 391
 392         @Test(enabled = false)
 393         public void importToscaResourceVFResType() throws Exception {
 394
 395                 String resourceType = ResourceTypeEnum.VF.toString();
 396
 397                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 398                                 importSuccessVFFile);
 399                 // importReqDetails.setResourceType(resourceType);
 400                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 401                                 null);
 402                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 403                 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 404                                 importResourceResponse.getErrorCode() == 201);
 405                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 406                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 407                 Resource resourceJavaObject = ResponseParser
 408                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 409                 assertTrue("validate toscaResourceName field",
 410                                 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
 411                 assertTrue(
 412                                 "validate resourceType field, expected - " + resourceType + ", actual - "
 413                                                 + resourceJavaObject.getResourceType(),
 414                                 resourceJavaObject.getResourceType().toString().equals(resourceType));
 415
 416                 // Validate audit message
 417                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 418                                 .getDefaultImportResourceAuditMsgSuccess();
 419                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 420                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 421                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 422                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 423                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 424                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 425         }
 426
 427         // ------------------------------Failure---------------------------------
 428
 429         @Test
 430         public void importToscaResourceDerivedFromNotExist() throws Exception {
 431
 432                 String fileName = importNoDerivedFromFile;
 433                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 434                                 fileName);
 435                 // List<String> derivedFrom = new ArrayList<String>() ;
 436                 // derivedFrom.add("hh");
 437                 // importReqDetails.setDerivedFrom(derivedFrom);
 438                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 439                                 null);
 440                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 441
 442                 // Validate audit message
 443                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 444                 assertNotNull("check error code exists in response after import tosca resource",
 445                                 importResourceResponse.getErrorCode());
 446
 447                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.PARENT_RESOURCE_NOT_FOUND.name());
 448                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 449                                 importResourceResponse.getErrorCode());
 450                 List<String> variables = Arrays.asList();
 451                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.PARENT_RESOURCE_NOT_FOUND.name(), variables,
 452                                 importResourceResponse.getResponse());
 453
 454                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 455                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 456                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 457                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 458                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 459                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 460                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 461                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 462                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 463                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 464         }
 465
 466         @Test
 467         public void importToscaResourceIncorrectDefinitionVersion() throws Exception {
 468
 469                 String fileName = importInvalidDefinitionVersionFile;
 470                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 471                                 fileName);
 472                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 473                                 null);
 474                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 475
 476                 // Validate audit message
 477                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 478                 assertNotNull("check error code exists in response after import tosca resource",
 479                                 importResourceResponse.getErrorCode());
 480
 481                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_TOSCA_TEMPLATE.name());
 482                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 483                                 importResourceResponse.getErrorCode());
 484                 List<String> variables = Arrays.asList();
 485                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_TOSCA_TEMPLATE.name(), variables,
 486                                 importResourceResponse.getResponse());
 487
 488                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 489                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 490                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 491                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 492                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 493                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 494                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 495         }
 496
 497         @Test
 498         public void importToscaResourceIncorrectSpaceNameFormat() throws Exception {
 499
 500                 String fileName = importIncorrectNameSpaceFormatFile;
 501                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 502                                 fileName);
 503                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 504                                 null);
 505                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 506
 507                 // Validate audit message
 508                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 509                 assertNotNull("check error code exists in response after import tosca resource",
 510                                 importResourceResponse.getErrorCode());
 511
 512                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_RESOURCE_NAMESPACE.name());
 513                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 514                                 importResourceResponse.getErrorCode());
 515                 List<String> variables = Arrays.asList();
 516                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_RESOURCE_NAMESPACE.name(), variables,
 517                                 importResourceResponse.getResponse());
 518
 519                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 520                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 521                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 522                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 523                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 524                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 525                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 526         }
 527
 528         @Test
 529         public void importToscaResourceNoDefinitionVersion() throws Exception {
 530
 531                 String fileName = importNoDefenitionVersionFile;
 532                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 533                                 fileName);
 534                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 535                                 null);
 536                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 537
 538                 // Validate audit message
 539                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 540                 assertNotNull("check error code exists in response after import tosca resource",
 541                                 importResourceResponse.getErrorCode());
 542
 543                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_TOSCA_TEMPLATE.name());
 544                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 545                                 importResourceResponse.getErrorCode());
 546                 List<String> variables = Arrays.asList();
 547                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_TOSCA_TEMPLATE.name(), variables,
 548                                 importResourceResponse.getResponse());
 549
 550                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 551                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 552                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 553                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 554                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 555                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 556                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 557         }
 558
 559         @Test
 560         public void importToscaResourceNoContent() throws Exception {
 561
 562                 String fileName = importNoContentFile;
 563                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 564                                 fileName);
 565                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 566                                 null);
 567                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 568
 569                 // Validate audit message
 570                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 571                 assertNotNull("check error code exists in response after import tosca resource",
 572                                 importResourceResponse.getErrorCode());
 573
 574                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_RESOURCE_PAYLOAD.name());
 575                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 576                                 importResourceResponse.getErrorCode());
 577                 List<String> variables = Arrays.asList();
 578                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_RESOURCE_PAYLOAD.name(), variables,
 579                                 importResourceResponse.getResponse());
 580
 581                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 582                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 583                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 584                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 585                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 586                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 587                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 588         }
 589
 590         @Test
 591         public void importToscaResourceWithTopologyTemplate() throws Exception {
 592
 593                 String fileName = importTopologyTemplateFile;
 594                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 595                                 fileName);
 596                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 597                                 null);
 598                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 599
 600                 // Validate audit message
 601                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 602                 assertNotNull("check error code exists in response after import tosca resource",
 603                                 importResourceResponse.getErrorCode());
 604
 605                 ErrorInfo errorInfo = ErrorValidationUtils
 606                                 .parseErrorConfigYaml(ActionStatus.NOT_RESOURCE_TOSCA_TEMPLATE.name());
 607                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 608                                 importResourceResponse.getErrorCode());
 609                 List<String> variables = Arrays.asList();
 610                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_RESOURCE_TOSCA_TEMPLATE.name(), variables,
 611                                 importResourceResponse.getResponse());
 612
 613                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 614                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 615                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 616                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 617                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 618                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 619                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 620         }
 621
 622         @Test
 623         public void importToscaResourceWithNodeTypesTwice() throws Exception {
 624
 625                 String fileName = importNodeTypesTwiceFile;
 626                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 627                                 fileName);
 628                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 629                                 null);
 630                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 631
 632                 // Validate audit message
 633                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 634                 assertNotNull("check error code exists in response after import tosca resource",
 635                                 importResourceResponse.getErrorCode());
 636
 637                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.NOT_SINGLE_RESOURCE.name());
 638                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 639                                 importResourceResponse.getErrorCode());
 640                 List<String> variables = Arrays.asList();
 641                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_SINGLE_RESOURCE.name(), variables,
 642                                 importResourceResponse.getResponse());
 643
 644                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 645                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 646                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 647                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 648                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 649                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 650                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 651         }
 652
 653         // failed case - uniqueness of toscaResourceName - RESOURCE_ALREADY_EXISTS
 654         @Test
 655         public void importToscaResourceTwice() throws Exception {
 656                 String fileName = importSuccessFile;
 657                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 658                                 fileName);
 659                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 660                                 null);
 661                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 662                 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 663                                 importResourceResponse.getErrorCode() == 201);
 664                 Resource resourceJavaObject = ResponseParser
 665                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 666                 RestResponse checkInresponse = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
 667                                 LifeCycleStatesEnum.CHECKIN);
 668                 assertTrue("checkIn resource request returned status:" + checkInresponse.getErrorCode(),
 669                                 checkInresponse.getErrorCode() == 200);
 670
 671                 // Validate audit message
 672                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 673                                 .getDefaultImportResourceAuditMsgSuccess();
 674                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 675                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 676                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 677                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 678                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 679                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 680                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 681                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 682
 683                 // import the same tosca resource with different resourceName
 684                 DbUtils.cleanAllAudits();
 685
 686                 importReqDetails.setName("kuku");
 687                 List<String> tags = new ArrayList<String>();
 688                 tags.add(importReqDetails.getName());
 689                 importReqDetails.setTags(tags);
 690                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
 691                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 692
 693                 // Validate audit message
 694                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 695                 assertNotNull("check error code exists in response after import tosca resource",
 696                                 importResourceResponse.getErrorCode());
 697
 698                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_ALREADY_EXISTS.name());
 699                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 700                                 importResourceResponse.getErrorCode());
 701                 List<String> variables = Arrays.asList();
 702                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_ALREADY_EXISTS.name(), variables,
 703                                 importResourceResponse.getResponse());
 704
 705                 expectedResourceAuditJavaObject = ElementFactory.getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 706                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 707                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 708                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 709                 expectedResourceAuditJavaObject.setToscaNodeType(importReqDetails.getToscaResourceName());
 710                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 711                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 712
 713         }
 714
 715         @Test
 716         public void importToscaResourceWithTheSameNameAsCreatedResourceBefore() throws Exception {
 717
 718                 // create resource
 719                 String fileName = importSuccessFile;
 720                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 721                                 fileName);
 722
 723                 resourceDetails = ElementFactory.getDefaultResource();
 724                 resourceDetails.setName(importReqDetails.getName());
 725
 726                 RestResponse response = ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
 727                 int status = response.getErrorCode();
 728                 assertEquals("create request returned status:" + status, 201, status);
 729                 assertNotNull("resource uniqueId is null:", resourceDetails.getUniqueId());
 730                 Resource resourceJavaObject = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 731                 // assertNull("validate toscaResourceName field",
 732                 // resourceJavaObject.getToscaResourceName());
 733
 734                 // import the same tosca resource
 735                 DbUtils.cleanAllAudits();
 736                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 737                                 null);
 738                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 739
 740                 // Validate audit message
 741                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 742                 assertNotNull("check error code exists in response after import tosca resource",
 743                                 importResourceResponse.getErrorCode());
 744
 745                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_ALREADY_EXISTS.name());
 746                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 747                                 importResourceResponse.getErrorCode());
 748                 List<String> variables = Arrays.asList();
 749                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_ALREADY_EXISTS.name(), variables,
 750                                 importResourceResponse.getResponse());
 751
 752                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 753                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 754                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 755                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 756                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 757                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 758                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 759
 760         }
 761
 762         @Test
 763         public void importToscaResourceInvalidChecksum() throws Exception {
 764                 String fileName = importSuccessFile;
 765                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 766                                 fileName);
 767                 Map<String, String> headersMap = new HashMap<String, String>();
 768                 headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), "invalidMd5Sum");
 769
 770                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 771                                 headersMap);
 772                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 773
 774                 // Validate audit message
 775                 assertNotNull("check response object is not null after import tosca resource", importResourceResponse);
 776                 assertNotNull("check error code exists in response after import tosca resource",
 777                                 importResourceResponse.getErrorCode());
 778
 779                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_RESOURCE_CHECKSUM.name());
 780                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 781                                 importResourceResponse.getErrorCode());
 782                 List<String> variables = Arrays.asList();
 783                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_RESOURCE_CHECKSUM.name(), variables,
 784                                 importResourceResponse.getResponse());
 785
 786                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 787                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 788                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 789                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 790                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 791                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 792                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 793         }
 794
 795         @Test
 796         public void importToscaResourceInvalidResType() throws Exception {
 797
 798                 String resourceType = "invalidResourceType";
 799
 800                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 801                                 importSuccessFile);
 802                 importReqDetails.setResourceType(resourceType);
 803                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 804                                 null);
 805
 806                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_CONTENT.name());
 807                 assertNotNull("check response object is not null after import resouce", importResourceResponse);
 808                 assertNotNull("check error code exists in response after import resource",
 809                                 importResourceResponse.getErrorCode());
 810                 assertEquals("Check response code after import resource", errorInfo.getCode(),
 811                                 importResourceResponse.getErrorCode());
 812
 813                 List<String> variables = new ArrayList<>();
 814                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), variables,
 815                                 importResourceResponse.getResponse());
 816
 817                 // Validate audit message
 818                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 819                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
 820                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 821                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 822                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 823                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 824                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 825         }
 826
 827         @Test
 828         public void derivedTemplateImportedSecondResourceAsFirstImportedNodeType() throws Exception {
 829
 830                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 831                                 importSuccessFile);
 832                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 833                                 null);
 834                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 835                 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 836                                 importResourceResponse.getErrorCode() == 201);
 837                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 838                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 839                 Resource resourceJavaObject = ResponseParser
 840                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 841                 assertTrue("validate toscaResourceName field",
 842                                 resourceJavaObject.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
 843                 assertTrue(
 844                                 "validate resourceType field, expected - " + importReqDetails.getResourceType() + ", actual - "
 845                                                 + resourceJavaObject.getResourceType(),
 846                                 resourceJavaObject.getResourceType().toString().equals(importReqDetails.getResourceType()));
 847
 848                 // Validate audit message
 849                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 850                                 .getDefaultImportResourceAuditMsgSuccess();
 851                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 852                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 853                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 854                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 855                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 856                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 857
 858                 RestResponse certifyResource = LifecycleRestUtils.certifyResource(importReqDetails);
 859                 assertTrue("certify resource request returned status:" + certifyResource.getErrorCode(),
 860                                 certifyResource.getErrorCode() == 200);
 861
 862                 // import second resource template derived from first resource
 863                 DbUtils.cleanAllAudits();
 864                 importReqDetails.setName("kuku");
 865                 List<String> tags = new ArrayList<String>();
 866                 tags.add(importReqDetails.getName());
 867                 importReqDetails.setTags(tags);
 868                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 869                                 derivedFromMyCompute);
 870                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
 871                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 872
 873                 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 874                                 importResourceResponse.getErrorCode() == 201);
 875                 parseToscaNodeYaml = utils.parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 876                 Resource resourceJavaObject2 = ResponseParser
 877                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 878                 assertTrue("validate toscaResourceName field",
 879                                 resourceJavaObject2.getToscaResourceName().equals(parseToscaNodeYaml.getNodeName()));
 880                 assertTrue(
 881                                 "validate resourceType field, expected - " + importReqDetails.getResourceType() + ", actual - "
 882                                                 + resourceJavaObject2.getResourceType(),
 883                                 resourceJavaObject2.getResourceType().toString().equals(importReqDetails.getResourceType()));
 884
 885                 // Validate audit message
 886                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject2 = ElementFactory
 887                                 .getDefaultImportResourceAuditMsgSuccess();
 888                 expectedResourceAuditJavaObject2.setResourceName(importReqDetails.getName());
 889                 expectedResourceAuditJavaObject2.setModifierName(sdncUserDetails.getFullName());
 890                 expectedResourceAuditJavaObject2.setModifierUid(sdncUserDetails.getUserId());
 891                 expectedResourceAuditJavaObject2.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 892                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject2,
 893                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 894
 895         }
 896
 897         @Test
 898         public void importToscaResourceListPropertyGoodDefault() throws Exception {
 899
 900                 String fileName = importListPropertyGoodDefault;
 901                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 902                                 fileName);
 903                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 904                                 null);
 905                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 906
 907                 assertTrue("response code is not 201, returned :" + importResourceResponse.getErrorCode(),
 908                                 importResourceResponse.getErrorCode() == 201);
 909
 910                 Resource resourceJavaObject = ResponseParser
 911                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 912                 assertTrue("Properties size : " + resourceJavaObject.getProperties().size(),
 913                                 resourceJavaObject.getProperties().size() == 1);
 914                 assertTrue("Property type : " + resourceJavaObject.getProperties().get(0).getType(),
 915                                 resourceJavaObject.getProperties().get(0).getType().equals(ToscaPropertyType.LIST.getType()));
 916                 assertTrue(
 917                                 "actual Default values  : " + resourceJavaObject.getProperties().get(0).getDefaultValue()
 918                                                 + " , expected : " + "[false, true]",
 919                                 resourceJavaObject.getProperties().get(0).getDefaultValue().equals("[\"false\",\"true\"]"));
 920
 921         }
 922
 923         @Test
 924         public void importToscaResourceListPropertyBadDefault() throws Exception {
 925
 926                 String fileName = importListPropertyBadDefault;
 927                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 928                                 fileName);
 929                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 930                                 null);
 931                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
 932
 933                 ErrorInfo errorInfo = ErrorValidationUtils
 934                                 .parseErrorConfigYaml(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name());
 935                 assertEquals("Check response code after tosca resource import", errorInfo.getCode(),
 936                                 importResourceResponse.getErrorCode());
 937                 ArrayList<String> variables = new ArrayList<>();
 938                 variables.add("my_prop");
 939                 variables.add("list");
 940                 variables.add("boolean");
 941                 variables.add("[12,true]");
 942                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name(), variables,
 943                                 importResourceResponse.getResponse());
 944
 945         }
 946
 947         // Benny US580744 - Add support for TOSCA "list" type - import
 948
 949         @Test
 950         public void importToscaResourceListPropertySuccessFlow() throws Exception {
 951                 String fileName = importListPropertySuccess;
 952                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 953                                 fileName);
 954                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 955                                 null);
 956                 ResourceRestUtils.checkCreateResponse(importResourceResponse);
 957                 Resource resourceJavaObject = ResponseParser
 958                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 959                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
 960                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
 961                 // Verify Properties List in resource
 962                 verifyResourcePropertiesList(resourceJavaObject);
 963                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
 964                                 .getDefaultImportResourceAuditMsgSuccess();
 965                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
 966                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
 967                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 968                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
 969                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 970                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
 971         }
 972
 973         // DE198534
 974         @Test(dataProvider = "getYmlWithInValidListProperties") // invalid default
 975                                                                                                                         // values
 976         public void importToscaResourceListPropertyFailureFlows(String ymlFileWithInvalidPropertyDefualtValues,
 977                         String defualtValues, String enterySchemaType) throws Exception {
 978                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 979                                 ymlFileWithInvalidPropertyDefualtValues);
 980                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 981                                 null);
 982                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
 983                 ArrayList<String> variables = new ArrayList<>();
 984                 variables.add("my_property");
 985                 variables.add("list");
 986                 variables.add(enterySchemaType);
 987                 variables.add(defualtValues);
 988                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name(), variables,
 989                                 importResourceResponse.getResponse());
 990         }
 991
 992         // BUG DE198650
 993         @Test
 994         public void importToscaResourceListPropertyNonSupportEntrySchemaType() throws Exception {
 995                 String ymlFile = "ListPropertyFalure01.yml";
 996                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
 997                                 ymlFile);
 998                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
 999                                 null);
1000                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1001                 ArrayList<String> variables = new ArrayList<>();
1002                 variables.add("booolean"); // property entry_schema data type
1003                 variables.add("my_boolean");
1004                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROPERTY_INNER_TYPE.name(), variables,
1005                                 importResourceResponse.getResponse());
1006         }
1007
1008         // BUG DE198676
1009         @Test // (enabled=false)
1010         public void importToscaResourceListPropertyNonSupportedPropertyType() throws Exception { // Not
1011                                                                                                                                                                                                 // "list"
1012                                                                                                                                                                                                 // type
1013                 String ymlFile = "ListPropertyFalure16.yml";
1014                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1015                                 ymlFile);
1016                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1017                                 null);
1018                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1019                 ArrayList<String> variables = new ArrayList<>();
1020                 variables.add("koko"); // property data type (koko instead list)
1021                 variables.add("my_boolean");
1022                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROPERTY_TYPE.name(), variables,
1023                                 importResourceResponse.getResponse());
1024         }
1025
1026         /// US656928 - [BE] - Add support for TOSCA "map" type - Phase 1 import
1027         @Test
1028         public void importToscaResourceMapPropertySuccessFlow() throws Exception {
1029                 String fileName = importMapPropertySuccess;
1030                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1031                                 fileName);
1032                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1033                                 null);
1034                 ResourceRestUtils.checkCreateResponse(importResourceResponse);
1035                 Resource resourceJavaObject = ResponseParser
1036                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
1037                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
1038                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
1039                 // Verify Properties MAP in resource
1040                 verifyResourcePropertiesMap(resourceJavaObject);
1041                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1042                                 .getDefaultImportResourceAuditMsgSuccess();
1043                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1044                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1045                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1046                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
1047                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1048                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1049         }
1050
1051         @Test(dataProvider = "getYmlWithInValidMapProperties") // invalid default
1052                                                                                                                         // values
1053         public void importToscaResourceMapPropertyFailureFlows(String ymlFileWithInvalidPropertyDefualtValues,
1054                         String defualtValues, String enterySchemaType) throws Exception {
1055                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1056                                 ymlFileWithInvalidPropertyDefualtValues);
1057                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1058                                 null);
1059                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1060                 ArrayList<String> variables = new ArrayList<>();
1061                 variables.add("my_property");
1062                 variables.add("map");
1063                 variables.add(enterySchemaType);
1064                 variables.add(defualtValues);
1065                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE.name(), variables,
1066                                 importResourceResponse.getResponse());
1067         }
1068
1069         @Test
1070         public void importToscaResourceMaptPropertyNonSupportedPropertyType() throws Exception { // Not
1071                                                                                                                                                                                                 // "Map"
1072                                                                                                                                                                                                 // type
1073                 String ymlFile = "MapPropertyFalure16.yml";
1074                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1075                                 ymlFile);
1076                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1077                                 null);
1078                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1079                 ArrayList<String> variables = new ArrayList<>();
1080                 variables.add("koko"); // property data type (koko instead list)
1081                 variables.add("my_boolean");
1082                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROPERTY_TYPE.name(), variables,
1083                                 importResourceResponse.getResponse());
1084         }
1085
1086         @Test
1087         public void importToscaResourceMissingCapabilityInReqDefinition() throws Exception {
1088
1089                 String fileName = missingCapInReqDef;
1090                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1091                                 fileName);
1092                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1093                                 null);
1094                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
1095
1096                 // Validate audit message
1097                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_CAPABILITY_TYPE.name());
1098                 String missingCapName = "org.openecomp.capabilities.networkInterfaceNotFound";
1099                 BaseRestUtils.checkErrorResponse(importResourceResponse, ActionStatus.MISSING_CAPABILITY_TYPE, missingCapName);
1100
1101                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1102                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, Arrays.asList(missingCapName));
1103                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1104                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1105                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1106                 expectedResourceAuditJavaObject.setToscaNodeType("org.openecomp.resource.vSCP-03-16");
1107                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1108                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1109         }
1110
1111         @Test
1112         public void importToscaResourceMissingCapabilityInCapDefinition() throws Exception {
1113
1114                 String fileName = missingCapInCapDef;
1115                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1116                                 fileName);
1117                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1118                                 null);
1119                 logger.debug("import tosca resource response:  {}", importResourceResponse.getResponseMessage());
1120
1121                 // Validate audit message
1122                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_CAPABILITY_TYPE.name());
1123                 String missingCapName = "org.openecomp.capabilities.networkInterfaceNotFound";
1124                 BaseRestUtils.checkErrorResponse(importResourceResponse, ActionStatus.MISSING_CAPABILITY_TYPE, missingCapName);
1125
1126                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1127                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, Arrays.asList(missingCapName));
1128                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1129                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1130                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1131                 expectedResourceAuditJavaObject.setToscaNodeType("org.openecomp.resource.vSCP-03-16");
1132                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1133                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1134         }
1135
1136         @Test
1137         public void importToscaResourceDuplicateRequirements() throws Exception {
1138                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1139                                 importDuplicateRequirements);
1140                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1141                                 null);
1142                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1143                 ArrayList<String> variables = new ArrayList<>();
1144                 variables.add("requirement");
1145                 variables.add("local_storage");
1146                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name(), variables,
1147                                 importResourceResponse.getResponse());
1148                 ErrorInfo errorInfo = ErrorValidationUtils
1149                                 .parseErrorConfigYaml(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name());
1150                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1151                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1152                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1153                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1154                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1155                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1156                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1157                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1158         }
1159
1160         @Test
1161         public void importToscaResourceDuplicateCapabilities() throws Exception {
1162                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1163                                 importDuplicateCapability);
1164                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1165                                 null);
1166                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1167                 ArrayList<String> variables = new ArrayList<>();
1168                 variables.add("capability");
1169                 variables.add("scalable");
1170                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name(), variables,
1171                                 importResourceResponse.getResponse());
1172                 ErrorInfo errorInfo = ErrorValidationUtils
1173                                 .parseErrorConfigYaml(ActionStatus.IMPORT_DUPLICATE_REQ_CAP_NAME.name());
1174                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1175                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1176                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1177                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1178                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1179                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1180                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1181                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1182         }
1183
1184         @Test
1185         public void importToscaResourceRequirementNameExistsOnParent() throws Exception {
1186                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1187                                 importRequirementNameExistsOnParent);
1188                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1189                                 null);
1190                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1191                 ArrayList<String> variables = new ArrayList<>();
1192                 variables.add("requirement");
1193                 variables.add("local_storage");
1194                 variables.add("Compute");
1195                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1196                                 variables, importResourceResponse.getResponse());
1197                 ErrorInfo errorInfo = ErrorValidationUtils
1198                                 .parseErrorConfigYaml(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name());
1199                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1200                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1201                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1202                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1203                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1204                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1205                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1206                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1207         }
1208
1209         @Test
1210         public void importToscaResourceCapabilityNameExistsOnParent() throws Exception {
1211                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1212                                 importCapabilityNameExistsOnParent);
1213                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1214                                 null);
1215                 assertTrue(importResourceResponse.getErrorCode().equals(STATUS_CODE_INVALID_CONTENT));
1216                 ArrayList<String> variables = new ArrayList<>();
1217                 variables.add("capability");
1218                 variables.add("binding");
1219                 variables.add("Compute");
1220                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1221                                 variables, importResourceResponse.getResponse());
1222                 ErrorInfo errorInfo = ErrorValidationUtils
1223                                 .parseErrorConfigYaml(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name());
1224                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1225                                 .getDefaultImportResourceAuditMsgFailure(errorInfo, variables);
1226                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1227                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1228                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1229                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
1230                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1231                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1232         }
1233
1234         @Test
1235         public void importToscaResourceReqCapDerivedFromParent() throws Exception {
1236                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1237                                 importToscaResourceReqCapDerivedFromParent);
1238                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1239                                 null);
1240                 BaseRestUtils.checkCreateResponse(importResourceResponse);
1241                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
1242                                 .getDefaultImportResourceAuditMsgSuccess();
1243                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
1244                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
1245                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1246                 expectedResourceAuditJavaObject.setToscaNodeType("org.openecomp.resource.MyWebApp");
1247                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1248                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
1249         }
1250
1251         /************************ Shay ************************/
1252
1253         @Test
1254         public void caseRequirementInsensitiveTest() throws Exception {
1255                 String fileName = "CaseInsensitiveReqTest_1.yml";
1256                 int expectedNumOfRequirements = 2;
1257                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1258                                 fileName);
1259                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1260                                 null);
1261                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1262                 importReqDetails.setRequirements(testResourcesPath, fileName, sdncUserDetails, null);
1263                 Map<String, Object> requirements = importReqDetails.getRequirements();
1264                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1265                                 expectedNumOfRequirements);
1266                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1267                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1268
1269                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1270                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1271                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1272                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1273                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1274                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1275                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1276                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1277                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1278
1279                 String fileName2 = "CaseInsensitiveReqTest_2.yml";
1280                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1281                                 fileName2);
1282                 importReqDetails.setName("secondImportedResource");
1283                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1284                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1285                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1286                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails, null);
1287                 requirements = importReqDetails.getRequirements();
1288                 requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1289                                 expectedNumOfRequirements);
1290                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1291                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1292
1293                 checkImportedAssetAssociated(importReqDetails);
1294
1295         }
1296
1297         private void checkImportedAssetAssociated(ImportReqDetails importDetails) throws IOException, Exception {
1298                 RestResponse importResourceResponse;
1299                 ImportReqDetails importReqDetails2 = ElementFactory.getDefaultImportResource();
1300                 importReqDetails2 = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails2, testResourcesPath,
1301                                 "BindingAsset.yml");
1302                 importReqDetails2.setName("bindingAsset");
1303                 importReqDetails2.setTags(Arrays.asList(importReqDetails2.getName()));
1304                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails2, sdncUserDetails, null);
1305                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1306
1307                 ResourceReqDetails vf = ElementFactory.getDefaultResourceByType("VF100", NormativeTypesEnum.ROOT,
1308                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncUserDetails.getUserId(),
1309                                 ResourceTypeEnum.VF.toString());
1310                 RestResponse createResourceResponse = ResourceRestUtils.createResource(vf, sdncUserDetails);
1311                 ResourceRestUtils.checkCreateResponse(createResourceResponse);
1312
1313                 LifecycleRestUtils.changeResourceState(importDetails, sdncUserDetails,
1314                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1315                 LifecycleRestUtils.changeResourceState(importReqDetails2, sdncUserDetails,
1316                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1317
1318                 RestResponse response = ResourceRestUtils.createResourceInstance(importDetails, sdncUserDetails,
1319                                 vf.getUniqueId());
1320                 ResourceRestUtils.checkCreateResponse(response);
1321                 ComponentInstance riCap = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
1322
1323                 response = ResourceRestUtils.createResourceInstance(importReqDetails2, sdncUserDetails, vf.getUniqueId());
1324                 ResourceRestUtils.checkCreateResponse(response);
1325                 ComponentInstance riReq = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
1326
1327                 RestResponse getResourceBeforeAssociate = ComponentRestUtils
1328                                 .getComponentRequirmentsCapabilities(sdncUserDetails, vf);
1329                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceBeforeAssociate.getResponse(), CapReqDef.class);
1330
1331                 String capbilityUid = capReqDef.getCapabilities().get("tosca.capabilities.network.Bindable").get(0)
1332                                 .getUniqueId();
1333                 String requirementUid = capReqDef.getRequirements().get("tosca.capabilities.network.Bindable").get(0)
1334                                 .getUniqueId();
1335
1336                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1337                 requirementDef.setFromNode(riReq.getUniqueId());
1338                 requirementDef.setToNode(riCap.getUniqueId());
1339
1340                 RelationshipInfo pair = new RelationshipInfo();
1341                 pair.setRequirementOwnerId(riReq.getUniqueId());
1342                 pair.setCapabilityOwnerId(riCap.getUniqueId());
1343                 pair.setRequirement("VirtualBinding");
1344                 RelationshipImpl relationship = new RelationshipImpl();
1345                 relationship.setType("tosca.capabilities.network.Bindable");
1346                 pair.setRelationships(relationship);
1347                 pair.setCapabilityUid(capbilityUid);
1348                 pair.setRequirementUid(requirementUid);
1349                 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
1350                 capReqRel.setRelation(pair);
1351                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1352                 relationships.add(capReqRel);
1353                 requirementDef.setRelationships(relationships);
1354
1355                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncUserDetails,
1356                                 vf.getUniqueId(), ComponentTypeEnum.RESOURCE);
1357                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1358         }
1359
1360         @Test
1361         public void caseCapabilitiesInsensitiveTest() throws Exception {
1362                 String fileName = "CaseInsensitiveCapTest_1.yml";
1363                 int expectedNumOfCapabilities = 6;
1364
1365                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1366                                 fileName);
1367                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1368                                 null);
1369                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1370
1371                 importReqDetails.setCapabilities(testResourcesPath, fileName, sdncUserDetails, null);
1372                 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1373                 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1374                                 expectedNumOfCapabilities);
1375                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1376                 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1377
1378                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1379                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1380                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1381                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1382                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1383                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1384                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1385                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1386                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1387
1388                 String fileName2 = "CaseInsensitiveCapTest_2.yml";
1389                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1390                                 fileName2);
1391                 importReqDetails.setName("secondImportedResource");
1392                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1393                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1394                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1395
1396                 importReqDetails.setCapabilities(testResourcesPath, fileName2, sdncUserDetails, null);
1397                 capabilities = importReqDetails.getCapabilities();
1398                 capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1399                                 expectedNumOfCapabilities);
1400                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1401                 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1402
1403         }
1404
1405         @Test
1406         public void fatherAndChildHaveDifferentRequirementsTest() throws Exception {
1407                 String fileName = "DifferentReqFromCompute.yml";
1408                 int expectedNumOfRequirements = 3;
1409
1410                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1411                                 fileName);
1412                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1413                                 null);
1414                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1415
1416                 importReqDetails.setRequirements(testResourcesPath, fileName, sdncUserDetails, "Compute");
1417                 Map<String, Object> requirements = importReqDetails.getRequirements();
1418                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1419                                 expectedNumOfRequirements);
1420                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1421                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1422
1423                 checkImportedAssetAssociated(importReqDetails);
1424         }
1425
1426         @Test
1427         public void fatherHasNoRequirementsTest() throws Exception {
1428                 String fatherFileName = "CPHasNoReqCap.yml";
1429                 String childFileName = "DerivedFromCPWithOwnReq.yml";
1430                 int expectedNumOfRequirements = 3;
1431
1432                 importReqDetails.setName("father");
1433                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1434                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1435                                 fatherFileName);
1436                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1437                                 null);
1438                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1439
1440                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1441                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1442                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1443                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1444                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1445                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1446                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1447                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1448                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1449
1450                 String derivedFromResourceName = importReqDetails.getName();
1451                 importReqDetails = ElementFactory.getDefaultImportResource();
1452                 importReqDetails.setName("child");
1453                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1454                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1455                                 childFileName);
1456                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1457                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1458
1459                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1460                                 derivedFromResourceName);
1461                 Map<String, Object> requirements = importReqDetails.getRequirements();
1462                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1463                                 expectedNumOfRequirements);
1464                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1465                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1466
1467         }
1468
1469         @Test
1470         public void childHasSameReqNameAndTypeLikeFatherTest() throws Exception {
1471                 String childFileName = "SameReqAsCompute.yml";
1472                 int expectedNumOfRequirements = 2;
1473
1474                 importReqDetails.setName("child");
1475                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1476                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1477                                 childFileName);
1478                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1479                                 null);
1480                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1481
1482                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails, null);
1483                 Map<String, Object> requirements = importReqDetails.getRequirements();
1484                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1485                                 expectedNumOfRequirements);
1486                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1487                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1488         }
1489
1490         @Test
1491         public void childHasSameCapNameAndTypeLikeFatherTest() throws Exception {
1492                 String childFileName = "SameCapAsCompute.yml";
1493                 int expectedNumOfCapabilities = 6;
1494
1495                 importReqDetails.setName("child");
1496                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1497                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1498                                 childFileName);
1499                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1500                                 null);
1501                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1502
1503                 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1504                                 "Compute");
1505                 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1506                 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1507                                 expectedNumOfCapabilities);
1508                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1509                 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1510         }
1511
1512         @Test
1513         public void childGetsAllRequirementsOfFatherAndGrandfatherTest() throws Exception {
1514                 int expectedNumOfRequirements = 4;
1515
1516                 String fatherFileName = "DifferentReqFromCompute.yml";
1517                 importReqDetails.setName("father");
1518                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1519                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1520                                 fatherFileName);
1521                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1522                                 null);
1523                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1524
1525                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1526                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1527                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1528                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1529                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1530                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1531                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1532                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1533                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1534
1535                 String derivedFromName = importReqDetails.getName();
1536                 String childFileName = "DifferentReqCapFromCompute1.yml";
1537                 importReqDetails = ElementFactory.getDefaultImportResource();
1538                 importReqDetails.setName("child");
1539                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1540                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1541                                 childFileName);
1542                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1543                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1544
1545                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1546                                 derivedFromName);
1547                 Map<String, Object> requirements = importReqDetails.getRequirements();
1548                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1549                                 expectedNumOfRequirements);
1550                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1551                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1552
1553         }
1554
1555         @Test
1556         public void childOverridesGrandfatherRequirementsTest() throws Exception {
1557                 int expectedNumOfRequirements = 3;
1558
1559                 String fatherFileName = "DifferentReqFromCompute.yml";
1560                 importReqDetails.setName("father");
1561                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1562                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1563                                 fatherFileName);
1564                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1565                                 null);
1566                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1567
1568                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1569                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1570                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1571                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1572                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1573                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1574                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1575                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1576                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1577
1578                 String derivedFromName = importReqDetails.getName();
1579                 String childFileName = "SameReqAsCompute_DerivedFromMyCompute1.yml";
1580                 importReqDetails = ElementFactory.getDefaultImportResource();
1581                 importReqDetails.setName("child");
1582                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1583                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1584                                 childFileName);
1585                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1586                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1587
1588                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1589                                 derivedFromName);
1590                 Map<String, Object> requirements = importReqDetails.getRequirements();
1591                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1592                                 expectedNumOfRequirements);
1593                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1594                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1595         }
1596
1597         @Test
1598         public void childAndGrandfatherHaveDifferenetReqiurementTypeTest() throws Exception {
1599                 int expectedNumOfRequirements = 3;
1600                 int expectedNumOfCapabilities = 6;
1601
1602                 String fatherName = "father";
1603                 String fatherFileName = "DifferentReqFromCompute.yml";
1604                 importReqDetails.setName(fatherName);
1605                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1606                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1607                                 fatherFileName);
1608                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1609                                 null);
1610                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1611
1612                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1613                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1614                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1615                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1616                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1617                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1618                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1619                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1620                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1621
1622                 String fatherUniqueId = importReqDetails.getUniqueId();
1623                 ImportReqDetails importReqDetailsFather = importReqDetails;
1624
1625                 String childFileName = "importRequirementNameExistsOnParent_DerivedFromMyCompute1.yml";
1626                 importReqDetails = ElementFactory.getDefaultImportResource();
1627                 importReqDetails.setName("child");
1628                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1629                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1630                                 childFileName);
1631                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1632                 assertEquals(STATUS_CODE_INVALID_CONTENT, importResourceResponse.getErrorCode().intValue());
1633                 ArrayList<String> variables = new ArrayList<>();
1634                 variables.add("requirement");
1635                 variables.add("local_storage");
1636                 variables.add(fatherName);
1637                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1638                                 variables, importResourceResponse.getResponse());
1639
1640                 importReqDetails.setUniqueId(fatherUniqueId);
1641
1642                 importReqDetailsFather.setRequirements(testResourcesPath, fatherFileName, sdncUserDetails, "Compute");
1643                 Map<String, Object> requirements = importReqDetailsFather.getRequirements();
1644                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetailsFather,
1645                                 expectedNumOfRequirements);
1646                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1647                 importReqDetailsFather.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1648
1649                 importReqDetailsFather.setCapabilities(testResourcesPath, fatherFileName, sdncUserDetails, "Compute");
1650                 Map<String, Object> capabilities = importReqDetailsFather.getCapabilities();
1651                 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetailsFather,
1652                                 expectedNumOfCapabilities);
1653                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1654                 importReqDetailsFather.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1655         }
1656
1657         @Test
1658         public void childHasNoReqCapTest() throws Exception {
1659                 int expectedNumOfRequirements = 3;
1660                 int expectedNumOfCapabilities = 6;
1661
1662                 String fatherFileName = "DifferentReqFromCompute.yml";
1663                 importReqDetails.setName("father");
1664                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1665                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1666                                 fatherFileName);
1667                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1668                                 null);
1669                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1670
1671                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1672                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1673                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1674                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1675                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1676                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1677                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1678                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1679                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1680
1681                 String derivedFromName = importReqDetails.getName();
1682                 String childFileName = "CPHasNoReqCap_DerivedFromMyCompute1.yml";
1683                 importReqDetails = ElementFactory.getDefaultImportResource();
1684                 importReqDetails.setName("child");
1685                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1686                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1687                                 childFileName);
1688                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1689                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1690
1691                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1692                                 derivedFromName);
1693                 Map<String, Object> requirements = importReqDetails.getRequirements();
1694                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1695                                 expectedNumOfRequirements);
1696                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1697                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1698
1699                 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1700                                 derivedFromName);
1701                 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1702                 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1703                                 expectedNumOfCapabilities);
1704                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1705                 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1706         }
1707
1708         @Test
1709         public void fatherAndChildGetReqCapFromGrandfatherTest() throws Exception {
1710                 int expectedNumOfRequirements = 2;
1711                 int expectedNumOfCapabilities = 6;
1712
1713                 String fatherFileName = "MyFatherCompute_NoReqCap.yml";
1714                 importReqDetails.setName("father");
1715                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1716                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1717                                 fatherFileName);
1718                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1719                                 null);
1720                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1721
1722                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1723                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1724                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1725                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1726                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1727                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1728                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1729                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1730                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1731
1732                 String derivedFromName = importReqDetails.getName();
1733                 String childFileName = "myChildCompute_NoReqCap.yml";
1734                 importReqDetails = ElementFactory.getDefaultImportResource();
1735                 importReqDetails.setName("child");
1736                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1737                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1738                                 childFileName);
1739                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1740                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1741
1742                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1743                                 derivedFromName);
1744                 Map<String, Object> requirements = importReqDetails.getRequirements();
1745                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1746                                 expectedNumOfRequirements);
1747                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1748                 importReqDetails.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1749
1750                 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1751                                 derivedFromName);
1752                 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1753                 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1754                                 expectedNumOfCapabilities);
1755                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1756                 importReqDetails.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1757         }
1758
1759         @Test
1760         public void reverseInheritanceTest() throws Exception {
1761                 int expectedNumOfRequirements = 2;
1762                 int expectedNumOfCapabilities = 2;
1763
1764                 String fatherName = "father";
1765                 String fatherFileName = "myFatherWebApp_derviedFromDocker.yml";
1766                 importReqDetails.setName(fatherName);
1767                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1768                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1769                                 fatherFileName);
1770                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1771                                 null);
1772                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1773
1774                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1775                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1776                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1777                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1778                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1779                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1780                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1781                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1782                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1783
1784                 String fatherUniqueId = importReqDetails.getUniqueId();
1785                 ImportReqDetails importReqDetailsFather = importReqDetails;
1786                 String childFileName = "myChildWebApp_DerivedFromContainer.yml";
1787                 importReqDetails = ElementFactory.getDefaultImportResource();
1788                 importReqDetails.setName("child");
1789                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1790                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1791                                 childFileName);
1792                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1793                 assertEquals(STATUS_CODE_INVALID_CONTENT, importResourceResponse.getErrorCode().intValue());
1794                 ArrayList<String> variables = new ArrayList<>();
1795                 variables.add("requirement");
1796                 variables.add("host");
1797                 variables.add(fatherName);
1798                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.IMPORT_REQ_CAP_NAME_EXISTS_IN_DERIVED.name(),
1799                                 variables, importResourceResponse.getResponse());
1800
1801                 importReqDetails.setUniqueId(fatherUniqueId);
1802                 importReqDetailsFather.setRequirements(testResourcesPath, fatherFileName, sdncUserDetails, "Root");
1803                 Map<String, Object> requirements = importReqDetailsFather.getRequirements();
1804                 Map<String, Object> requirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetailsFather,
1805                                 expectedNumOfRequirements);
1806                 assertEquals(requirements.keySet().size(), requirementsFromResponse.keySet().size());
1807                 importReqDetailsFather.compareRequirementsOrCapabilities(requirements, requirementsFromResponse);
1808
1809                 importReqDetailsFather.setCapabilities(testResourcesPath, fatherFileName, sdncUserDetails, "Root");
1810                 Map<String, Object> capabilities = importReqDetailsFather.getCapabilities();
1811                 Map<String, Object> capabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetailsFather,
1812                                 expectedNumOfCapabilities);
1813                 assertEquals(capabilities.keySet().size(), capabilitiesFromResponse.keySet().size());
1814                 importReqDetailsFather.compareRequirementsOrCapabilities(capabilities, capabilitiesFromResponse);
1815         }
1816
1817         // DE202329
1818         @Test(enabled = false)
1819         public void requirementWithMissingTypeTest() throws Exception {
1820                 String fatherName = "father";
1821                 String fatherFileName = "DerivedFromWebApplication_HasNoReqType.yml";
1822                 importReqDetails.setName(fatherName);
1823                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1824                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1825                                 fatherFileName);
1826                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1827                                 null);
1828                 assertEquals(STATUS_CODE_INVALID_CONTENT, importResourceResponse.getErrorCode().intValue());
1829                 ArrayList<String> variables = new ArrayList<>();
1830                 variables.add("diff");
1831                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_CAPABILITY_TYPE.name(), variables,
1832                                 importResourceResponse.getResponse());
1833
1834         }
1835
1836         @Test
1837         public void TwinBrothersHaveSameReqCapTest() throws Exception {
1838                 int expectedNumOfRequirements = 4;
1839                 int expectedNumOfCapabilities = 7;
1840
1841                 String derivedFromName = "father";
1842                 String fatherFileName = "DifferentReqFromCompute.yml";
1843                 importReqDetails.setName(derivedFromName);
1844                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1845                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1846                                 fatherFileName);
1847                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
1848                                 null);
1849                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1850
1851                 RestResponse changeResourceState1 = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1852                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1853                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState1.getErrorCode().intValue());
1854                 RestResponse changeResourceState2 = LifecycleRestUtils.changeResourceState(importReqDetails,
1855                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION);
1856                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState2.getErrorCode().intValue());
1857                 RestResponse changeResourceState3 = LifecycleRestUtils.changeResourceState(importReqDetails,
1858                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY);
1859                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState3.getErrorCode().intValue());
1860
1861                 String childFileName = "DifferentReqCapFromCompute1.yml";
1862                 importReqDetails = ElementFactory.getDefaultImportResource();
1863                 importReqDetails.setName("child");
1864                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1865                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1866                                 childFileName);
1867                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1868                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1869
1870                 Map<String, Object> childRequirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1871                                 expectedNumOfRequirements);
1872                 Map<String, Object> childCapabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1873                                 expectedNumOfCapabilities - 1);
1874
1875                 String twinFileName = "DifferentReqCapFromCompute2.yml";
1876                 importReqDetails = ElementFactory.getDefaultImportResource();
1877                 importReqDetails.setName("twin");
1878                 importReqDetails.setTags(Arrays.asList(importReqDetails.getName()));
1879                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1880                                 twinFileName);
1881                 importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails, null);
1882                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
1883
1884                 importReqDetails.setRequirements(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1885                                 derivedFromName);
1886                 Map<String, Object> requirements = importReqDetails.getRequirements();
1887                 Map<String, Object> twinRequirementsFromResponse = parseReqOrCapFromResponse("requirements", importReqDetails,
1888                                 expectedNumOfRequirements);
1889                 assertEquals(requirements.keySet().size(), twinRequirementsFromResponse.keySet().size());
1890                 importReqDetails.compareRequirementsOrCapabilities(requirements, twinRequirementsFromResponse);
1891
1892                 importReqDetails.setCapabilities(testResourcesPath, importReqDetails.getPayloadName(), sdncUserDetails,
1893                                 derivedFromName);
1894                 Map<String, Object> capabilities = importReqDetails.getCapabilities();
1895                 Map<String, Object> twinCapabilitiesFromResponse = parseReqOrCapFromResponse("capabilities", importReqDetails,
1896                                 expectedNumOfCapabilities);
1897                 assertEquals(capabilities.keySet().size(), twinCapabilitiesFromResponse.keySet().size());
1898                 importReqDetails.compareRequirementsOrCapabilities(capabilities, twinCapabilitiesFromResponse);
1899
1900                 assertEquals(childRequirementsFromResponse.keySet().size(), twinRequirementsFromResponse.keySet().size());
1901                 assertEquals(childCapabilitiesFromResponse.keySet().size(), twinCapabilitiesFromResponse.keySet().size());
1902         }
1903
1904         /*
1905          * invariantUUID - US672129
1906          */
1907
1908         private void checkInvariantUuidIsImmutableInDifferentAction(ImportReqDetails importReqDetails) throws Exception {
1909                 // create resource
1910                 importReqDetails.setName("import");
1911                 String invariantUuidDefinedByUser = "abcd1234";
1912                 RestResponse importResourceResponse = importResourceWithRequestedInvariantUuid(importReqDetails,
1913                                 invariantUuidDefinedByUser);
1914                 String invariantUUIDcreation = ResponseParser.getInvariantUuid(importResourceResponse);
1915                 assertFalse(checkInvariantUuidEqual(invariantUuidDefinedByUser, importResourceResponse));
1916
1917                 // get resource
1918                 RestResponse getResource = ResourceRestUtils.getResource(importReqDetails.getUniqueId());
1919                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, getResource));
1920
1921                 // checkin resource
1922                 RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1923                                 LifeCycleStatesEnum.CHECKIN);
1924                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1925                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1926
1927                 // checkout resource
1928                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1929                                 LifeCycleStatesEnum.CHECKOUT);
1930                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1931                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1932
1933                 // checkin resource
1934                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1935                                 LifeCycleStatesEnum.CHECKIN);
1936                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1937                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1938
1939                 // checkout resource
1940                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1941                                 LifeCycleStatesEnum.CHECKOUT);
1942                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1943                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1944
1945                 // checkin resource
1946                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1947                                 LifeCycleStatesEnum.CHECKIN);
1948                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1949                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1950
1951                 // certification request
1952                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1953                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1954                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1955                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1956
1957                 // start certification
1958                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
1959                                 LifeCycleStatesEnum.STARTCERTIFICATION);
1960                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1961                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1962
1963                 // certify
1964                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
1965                                 LifeCycleStatesEnum.CERTIFY);
1966                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1967                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1968                 String certifiedUniqueId = importReqDetails.getUniqueId();
1969
1970                 // update resource
1971                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1972                                 LifeCycleStatesEnum.CHECKOUT);
1973                 ResourceReqDetails updatedResourceReqDetails = new ResourceReqDetails(importReqDetails,
1974                                 importReqDetails.getVersion());
1975                 updatedResourceReqDetails.setDescription("updatedDescription");
1976                 updatedResourceReqDetails.setVendorRelease("1.2.3.4");
1977                 RestResponse updateResponse = ResourceRestUtils.updateResourceMetadata(updatedResourceReqDetails,
1978                                 sdncUserDetails, importReqDetails.getUniqueId());
1979                 assertEquals(STATUS_CODE_SUCCESS, updateResponse.getErrorCode().intValue());
1980                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, updateResponse));
1981
1982                 // certification request
1983                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1984                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1985                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1986                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1987
1988                 // checkout resource
1989                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1990                                 LifeCycleStatesEnum.CHECKOUT);
1991                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1992                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1993
1994                 // certification request
1995                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
1996                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1997                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1998                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
1999
2000                 // start certification
2001                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2002                                 LifeCycleStatesEnum.STARTCERTIFICATION);
2003                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2004                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2005
2006                 // cancel certification
2007                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2008                                 LifeCycleStatesEnum.CANCELCERTIFICATION);
2009                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2010                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2011
2012                 // start certification
2013                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2014                                 LifeCycleStatesEnum.STARTCERTIFICATION);
2015                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2016                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2017
2018                 // failure
2019                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, testerUser,
2020                                 LifeCycleStatesEnum.FAILCERTIFICATION);
2021                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2022                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2023
2024                 // upload artifact
2025                 changeResourceState = LifecycleRestUtils.changeResourceState(importReqDetails, sdncUserDetails,
2026                                 LifeCycleStatesEnum.CHECKOUT);
2027                 ArtifactReqDetails artifactDetails = ElementFactory.getDefaultArtifact();
2028                 ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails, sdncUserDetails,
2029                                 importReqDetails.getUniqueId());
2030                 assertEquals(STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
2031                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, changeResourceState));
2032
2033                 // create instance
2034                 resourceDetails.setResourceType(ResourceTypeEnum.VF.toString());
2035                 ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
2036                 importReqDetails.setUniqueId(certifiedUniqueId);
2037                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory
2038                                 .getComponentResourceInstance(importReqDetails);
2039                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
2040                                 resourceInstanceReqDetails, sdncUserDetails, resourceDetails.getUniqueId(), ComponentTypeEnum.RESOURCE);
2041                 assertEquals(STATUS_CODE_CREATED, createResourceInstanceResponse.getErrorCode().intValue());
2042                 getResource = ResourceRestUtils.getResource(importReqDetails.getUniqueId());
2043                 assertTrue(checkInvariantUuidEqual(invariantUUIDcreation, getResource));
2044         }
2045
2046         private boolean checkInvariantUuidEqual(String expectedInvariantUuid, RestResponse response) {
2047                 String invariantUUIDFromResponse = ResponseParser.getInvariantUuid(response);
2048                 return expectedInvariantUuid.equals(invariantUUIDFromResponse);
2049         }
2050
2051         @Test
2052         public void checkCPHasImmutableInvariantUuidTest() throws Exception {
2053                 String filename = "FatherHasNoReqCap.yml";
2054                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
2055                                 filename);
2056                 checkResourceHasImmutableInvariantUuidTest(importReqDetails);
2057         }
2058
2059         @Test
2060         public void checkVFCHasImmutableInvariantUuidTest() throws Exception {
2061                 String filename = "computeCap11.yml";
2062                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
2063                                 filename);
2064                 checkResourceHasImmutableInvariantUuidTest(importReqDetails);
2065         }
2066
2067         public void checkResourceHasImmutableInvariantUuidTest(ImportReqDetails importReqDetails) throws Exception {
2068                 // invariantUuid is null
2069                 importReqDetails.setName("first");
2070                 RestResponse importResourceResponse = importResourceWithRequestedInvariantUuid(importReqDetails, null);
2071                 String invariantUUIDcreation = ResponseParser.getInvariantUuid(importResourceResponse);
2072                 assertNotNull(invariantUUIDcreation);
2073
2074                 ResourceRestUtils.deleteResource(importReqDetails.getUniqueId(), sdncUserDetails.getUserId());
2075
2076                 // invariantUuid is empty
2077                 importReqDetails.setName("second");
2078                 String invariantUuidDefinedByUser = "";
2079                 importResourceResponse = importResourceWithRequestedInvariantUuid(importReqDetails, invariantUuidDefinedByUser);
2080                 invariantUUIDcreation = ResponseParser.getInvariantUuid(importResourceResponse);
2081                 assertNotNull(invariantUUIDcreation);
2082
2083                 ResourceRestUtils.deleteResource(importReqDetails.getUniqueId(), sdncUserDetails.getUserId());
2084
2085                 checkInvariantUuidIsImmutableInDifferentAction(importReqDetails);
2086         }
2087
2088         private static RestResponse importResourceWithRequestedInvariantUuid(ImportReqDetails importDetails,
2089                         String invariantUuid) throws Exception {
2090                 importDetails.setInvariantUUID(invariantUuid);
2091                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importDetails, sdncUserDetails,
2092                                 null);
2093                 assertEquals(STATUS_CODE_CREATED, importResourceResponse.getErrorCode().intValue());
2094                 return importResourceResponse;
2095         }
2096
2097         private Map<String, Object> parseReqOrCapFromResponse(String parsedFieldName, ImportReqDetails importReqDetails,
2098                         int expectedNumOfReqCap) throws ClientProtocolException, IOException {
2099                 RestResponse getResource = ResourceRestUtils.getResource(importReqDetails.getUniqueId());
2100                 assertTrue(getResource.getErrorCode().equals(STATUS_CODE_SUCCESS));
2101                 Map<String, Object> parsedFieldFromResponseToMap = ResponseParser.getJsonValueAsMap(getResource,
2102                                 parsedFieldName);
2103                 Iterator<String> iterator = parsedFieldFromResponseToMap.keySet().iterator();
2104                 actualNumOfReqOrCap = 0;
2105                 while (iterator.hasNext()) {
2106                         String next = iterator.next();
2107                         List<Object> object = (List<Object>) parsedFieldFromResponseToMap.get(next);
2108                         actualNumOfReqOrCap += object.size();
2109                 }
2110                 assertEquals(expectedNumOfReqCap, actualNumOfReqOrCap);
2111                 return parsedFieldFromResponseToMap;
2112         }
2113
2114         // ---------------------------------
2115
2116         private void verifyResourcePropertiesList(Resource resourceJavaObject) { // use
2117                                                                                                                                                                 // importListPropertySuccessFlow.yml
2118                 boolean isPropertyAppear = false;
2119                 List<PropertyDefinition> propertiesList = resourceJavaObject.getProperties();
2120                 for (PropertyDefinition pro : propertiesList) {
2121                         switch (pro.getName()) {
2122                         case "my_boolean":
2123                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2124                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[false,true]"));
2125                                 assertTrue("Check entrySchema Property Type ",
2126                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2127                                 isPropertyAppear = true;
2128                                 break;
2129                         case "my_boolean_array":
2130                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2131                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[true,false]"));
2132                                 assertTrue("Check entrySchema Property Type ",
2133                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2134                                 isPropertyAppear = true;
2135                                 break;
2136                         case "duplicate_boolean_values":
2137                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2138                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[true,false,true]"));
2139                                 assertTrue("Check entrySchema Property Type ",
2140                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2141                                 isPropertyAppear = true;
2142                                 break;
2143                         case "boolean_values_Insensitive":
2144                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2145                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[true,false,true]"));
2146                                 assertTrue("Check entrySchema Property Type ",
2147                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2148                                 isPropertyAppear = true;
2149                                 break;
2150                         case "my_integers":
2151                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2152                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[0,1000,-1000,50]"));
2153                                 assertTrue("Check entrySchema Property Type ",
2154                                                 pro.getSchema().getProperty().getType().equals("integer"));
2155                                 isPropertyAppear = true;
2156                                 break;
2157                         case "my_integers_array":
2158                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2159                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[10,-1000,0]"));
2160                                 assertTrue("Check entrySchema Property Type ",
2161                                                 pro.getSchema().getProperty().getType().equals("integer"));
2162                                 isPropertyAppear = true;
2163                                 break;
2164                         case "duplicate_integers_values":
2165                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2166                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[10,10,-1000,0]"));
2167                                 assertTrue("Check entrySchema Property Type ",
2168                                                 pro.getSchema().getProperty().getType().equals("integer"));
2169                                 isPropertyAppear = true;
2170                                 break;
2171                         case "my_string":
2172                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2173                                 assertTrue("Check Property  default values ",
2174                                                 pro.getDefaultValue().equals("[\"asdc\",\"$?^@ecomp$!#%()_-~@+*^...;;/w#\",\"uc\"]"));
2175                                 // assertTrue("Check Property default values ",
2176                                 // pro.getDefaultValue().equals("[\"asdc\",\"@=~!@#$%^&*()_+=?><:-w\",\"uc\"]"));
2177                                 assertTrue("Check entrySchema Property Type ",
2178                                                 pro.getSchema().getProperty().getType().equals("string"));
2179                                 isPropertyAppear = true;
2180                                 break;
2181                         case "my_string_array":
2182                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2183                                 assertTrue("Check Property  default values ",
2184                                                 pro.getDefaultValue().equals("[\"AAA\",\"~$~#bbb%^*_-\",\"qwe\",\"1.3\",\"500\",\"true\"]"));
2185                                 assertTrue("Check entrySchema Property Type ",
2186                                                 pro.getSchema().getProperty().getType().equals("string"));
2187                                 isPropertyAppear = true;
2188                                 break;
2189                         case "duplicate_string_values":
2190                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2191                                 assertTrue("Check Property  default values ",
2192                                                 pro.getDefaultValue().equals("[\"asdc\",\"asdc\",\"uc\"]"));
2193                                 assertTrue("Check entrySchema Property Type ",
2194                                                 pro.getSchema().getProperty().getType().equals("string"));
2195                                 isPropertyAppear = true;
2196                                 break;
2197                         case "string_null_value":
2198                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2199                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[\"asdc\",\"uc\"]"));
2200                                 assertTrue("Check entrySchema Property Type ",
2201                                                 pro.getSchema().getProperty().getType().equals("string"));
2202                                 isPropertyAppear = true;
2203                                 break;
2204                         case "string_space_value":
2205                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2206                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[\"asdc\",\"uc\"]"));
2207                                 assertTrue("Check entrySchema Property Type ",
2208                                                 pro.getSchema().getProperty().getType().equals("string"));
2209                                 isPropertyAppear = true;
2210                                 break;
2211                         case "string_array_null_value":
2212                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2213                                 assertTrue("Check Property  default values ",
2214                                                 pro.getDefaultValue().equals("[\"aaa\",\"bbb\",\"500\"]"));
2215                                 assertTrue("Check entrySchema Property Type ",
2216                                                 pro.getSchema().getProperty().getType().equals("string"));
2217                                 isPropertyAppear = true;
2218                                 break;
2219                         case "my_float":
2220                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2221                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[6,1000.000001,-3.0]"));
2222                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2223                                 isPropertyAppear = true;
2224                                 break;
2225                         case "my_float_array":
2226                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2227                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[0.01,-5.0,2.1]"));
2228                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2229                                 isPropertyAppear = true;
2230                                 break;
2231                         case "duplicate_float_values":
2232                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2233                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[0.0,0.0,4.555555]"));
2234                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2235                                 isPropertyAppear = true;
2236                                 break;
2237                         case "float_no_default_values":
2238                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2239                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2240                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2241                                 isPropertyAppear = true;
2242                                 break;
2243                         case "integer_no_default_values":
2244                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2245                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2246                                 assertTrue("Check entrySchema Property Type ",
2247                                                 pro.getSchema().getProperty().getType().equals("integer"));
2248                                 isPropertyAppear = true;
2249                                 break;
2250                         case "string_no_default_values":
2251                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2252                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2253                                 assertTrue("Check entrySchema Property Type ",
2254                                                 pro.getSchema().getProperty().getType().equals("string"));
2255                                 isPropertyAppear = true;
2256                                 break;
2257                         case "boolean_no_default_values":
2258                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2259                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2260                                 assertTrue("Check entrySchema Property Type ",
2261                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2262                                 isPropertyAppear = true;
2263                                 break;
2264                         case "integer_null_value":
2265                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2266                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[1000,2000]"));
2267                                 assertTrue("Check entrySchema Property Type ",
2268                                                 pro.getSchema().getProperty().getType().equals("integer"));
2269                                 isPropertyAppear = true;
2270                                 break;
2271                         case "boolean_null_value":
2272                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2273                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[true,false]"));
2274                                 assertTrue("Check entrySchema Property Type ",
2275                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2276                                 isPropertyAppear = true;
2277                                 break;
2278                         case "float_null_value":
2279                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2280                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[6,-3.0]"));
2281                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2282                                 isPropertyAppear = true;
2283                                 break;
2284                         case "float_space_value":
2285                                 assertTrue("Check Property Type ", pro.getType().equals("list"));
2286                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("[6,-3.0]"));
2287                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2288                                 isPropertyAppear = true;
2289                                 break;
2290
2291                         }
2292                         assertTrue(isPropertyAppear);
2293                         isPropertyAppear = false;
2294                 }
2295
2296         }
2297
2298         private void verifyRequirementsOccurrences(Resource resourceJavaObject, String requirementsType) {
2299                 boolean isRequirementAppear = false;
2300                 // List<RequirementDefinition> requerments =
2301                 // resourceJavaObject.getRequirements().get("tosca.capabilities.Attachment");
2302                 List<RequirementDefinition> requerments = resourceJavaObject.getRequirements().get(requirementsType);
2303
2304                 for (RequirementDefinition req : requerments) {
2305                         switch (req.getName()) {
2306                         case "local_storage100":
2307                                 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2308                                 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("UNBOUNDED"));
2309                                 isRequirementAppear = true;
2310                                 break;
2311                         case "local_storage200":
2312                                 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2313                                 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("1"));
2314                                 isRequirementAppear = true;
2315                                 break;
2316                         case "local_storage300":
2317                                 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2318                                 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("10"));
2319                                 isRequirementAppear = true;
2320                                 break;
2321                         case "local_storage400":
2322                                 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2323                                 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("10000000"));
2324                                 isRequirementAppear = true;
2325                                 break;
2326                         case "local_storage500":
2327                                 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("2"));
2328                                 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("3"));
2329                                 isRequirementAppear = true;
2330                                 break;
2331                         case "local_storageNoOccurrences600":
2332                                 assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals("1"));
2333                                 assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals("1"));
2334                                 isRequirementAppear = true;
2335                                 break;
2336                         }
2337                         assertTrue(isRequirementAppear);
2338                         isRequirementAppear = false;
2339                 }
2340
2341         }
2342
2343         private void verifyCapabilitiesOccurrences(Resource resourceJavaObject, String capabilitType) {
2344                 boolean isCapabilityAppear = false;
2345                 // List<CapabilityDefinition> capabilities =
2346                 // resourceJavaObject.getCapabilities().get("tosca.capabilities.Endpoint.Admin");
2347                 List<CapabilityDefinition> capabilities = resourceJavaObject.getCapabilities().get(capabilitType);
2348
2349                 for (CapabilityDefinition cap : capabilities) {
2350                         switch (cap.getName()) {
2351                         case "endpointNoOccurrence":
2352                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2353                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("UNBOUNDED"));
2354                                 isCapabilityAppear = true;
2355                                 break;
2356                         case "endpoint200":
2357                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2358                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("2"));
2359                                 isCapabilityAppear = true;
2360                                 break;
2361                         case "endpoint300":
2362                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2363                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("1"));
2364                                 isCapabilityAppear = true;
2365                                 break;
2366                         case "endpoint400":
2367                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2368                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("10"));
2369                                 isCapabilityAppear = true;
2370                                 break;
2371                         case "endpoint500":
2372                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2373                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("10000000"));
2374                                 isCapabilityAppear = true;
2375                                 break;
2376                         case "endpoint600":
2377                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("1"));
2378                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("UNBOUNDED"));
2379                                 isCapabilityAppear = true;
2380                                 break;
2381                         case "endpoint700":
2382                                 assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals("2"));
2383                                 assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals("4"));
2384                                 isCapabilityAppear = true;
2385                                 break;
2386
2387                         }
2388                         assertTrue(isCapabilityAppear);
2389                         isCapabilityAppear = false;
2390                 }
2391
2392         }
2393
2394         private void verifyResourcePropertiesMap(Resource resourceJavaObject) { // use
2395                                                                                                                                                         // importMapPropertySuccessFlow.yml
2396                 boolean isPropertyAppear = false;
2397                 List<PropertyDefinition> propertiesList = resourceJavaObject.getProperties();
2398                 for (PropertyDefinition pro : propertiesList) {
2399                         switch (pro.getName()) {
2400                         case "string_prop01":
2401                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2402                                 assertTrue("Check Property  default values ",
2403                                                 pro.getDefaultValue().equals("{\"keyA\":\"val1\",\"keyB\":\"val2\"}"));
2404                                 assertTrue("Check entrySchema Property Type ",
2405                                                 pro.getSchema().getProperty().getType().equals("string"));
2406                                 isPropertyAppear = true;
2407                                 break;
2408                         case "string_prop02":
2409                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2410                                 assertTrue("Check Property  default values ",
2411                                                 pro.getDefaultValue().equals("{\"keyA\":\"val1\",\"keyB\":\"val2\"}"));
2412                                 assertTrue("Check entrySchema Property Type ",
2413                                                 pro.getSchema().getProperty().getType().equals("string"));
2414                                 isPropertyAppear = true;
2415                                 break;
2416                         case "string_prop03":
2417                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2418                                 assertTrue("Check Property  default values ",
2419                                                 pro.getDefaultValue().equals("{\"keyA\":\"val1\",\"keyB\":\"val2\"}"));
2420                                 assertTrue("Check entrySchema Property Type ",
2421                                                 pro.getSchema().getProperty().getType().equals("string"));
2422                                 isPropertyAppear = true;
2423                                 break;
2424                         case "string_prop04":
2425                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2426                                 assertTrue("Check Property  default values ",
2427                                                 pro.getDefaultValue().equals("{\"keyA\":\"10\",\"keyB\":\"true\"}"));
2428                                 assertTrue("Check entrySchema Property Type ",
2429                                                 pro.getSchema().getProperty().getType().equals("string"));
2430                                 isPropertyAppear = true;
2431                                 break;
2432                         case "string_prop05":
2433                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2434                                 assertTrue("Check Property  default values ",
2435                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":\"Big\"}"));
2436                                 assertTrue("Check entrySchema Property Type ",
2437                                                 pro.getSchema().getProperty().getType().equals("string"));
2438                                 isPropertyAppear = true;
2439                                 break;
2440                         case "string_prop06":
2441                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2442                                 assertTrue("Check Property  default values ",
2443                                                 pro.getDefaultValue().equals("{\"keyA\":\"aaaA\",\"keyB\":null}"));
2444                                 assertTrue("Check entrySchema Property Type ",
2445                                                 pro.getSchema().getProperty().getType().equals("string"));
2446                                 isPropertyAppear = true;
2447                                 break;
2448                         case "string_prop07":
2449                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2450                                 assertTrue("Check Property  default values ",
2451                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null}"));
2452                                 assertTrue("Check entrySchema Property Type ",
2453                                                 pro.getSchema().getProperty().getType().equals("string"));
2454                                 isPropertyAppear = true;
2455                                 break;
2456                         case "string_prop08":
2457                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2458                                 assertTrue("Check Property  default values ",
2459                                                 pro.getDefaultValue().equals("{\"keyA\":\"\",\"keyB\":\"abcd\"}"));
2460                                 assertTrue("Check entrySchema Property Type ",
2461                                                 pro.getSchema().getProperty().getType().equals("string"));
2462                                 isPropertyAppear = true;
2463                                 break;
2464                         case "string_prop09":
2465                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2466                                 assertTrue("Check Property  default values ",
2467                                                 pro.getDefaultValue().equals("{\"keyA\":\" \",\"keyB\":\"abcd\"}"));
2468                                 assertTrue("Check entrySchema Property Type ",
2469                                                 pro.getSchema().getProperty().getType().equals("string"));
2470                                 isPropertyAppear = true;
2471                                 break;
2472                         case "string_prop10":
2473                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2474                                 assertTrue("Check Property  default values ",
2475                                                 pro.getDefaultValue().equals("{\"keyA\":\" aaaa\",\"keyB\":\" bbbb\"}"));
2476                                 assertTrue("Check entrySchema Property Type ",
2477                                                 pro.getSchema().getProperty().getType().equals("string"));
2478                                 isPropertyAppear = true;
2479                                 break;
2480                         case "string_prop11":
2481                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2482                                 assertTrue("Check Property  default values ",
2483                                                 pro.getDefaultValue().equals("{\"keyA\":\"aaaa \",\"keyB\":\"bbbb \"}"));
2484                                 assertTrue("Check entrySchema Property Type ",
2485                                                 pro.getSchema().getProperty().getType().equals("string"));
2486                                 isPropertyAppear = true;
2487                                 break;
2488                         case "string_prop12":
2489                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2490                                 assertTrue("Check Property  default values ",
2491                                                 pro.getDefaultValue().equals("{\"keyA\":\" aaaa \",\"keyB\":\" bbbb ccccc \"}"));
2492                                 assertTrue("Check entrySchema Property Type ",
2493                                                 pro.getSchema().getProperty().getType().equals("string"));
2494                                 isPropertyAppear = true;
2495                                 break;
2496                         case "string_prop13":
2497                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2498                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\"aaaa\"}"));
2499                                 assertTrue("Check entrySchema Property Type ",
2500                                                 pro.getSchema().getProperty().getType().equals("string"));
2501                                 isPropertyAppear = true;
2502                                 break;
2503                         case "string_prop14":
2504                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2505                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\" aaaa \"}"));
2506                                 assertTrue("Check entrySchema Property Type ",
2507                                                 pro.getSchema().getProperty().getType().equals("string"));
2508                                 isPropertyAppear = true;
2509                                 break;
2510                         case "string_prop15":
2511                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2512                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2513                                 assertTrue("Check entrySchema Property Type ",
2514                                                 pro.getSchema().getProperty().getType().equals("string"));
2515                                 isPropertyAppear = true;
2516                                 break;
2517                         case "string_prop16":
2518                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2519                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2520                                 assertTrue("Check entrySchema Property Type ",
2521                                                 pro.getSchema().getProperty().getType().equals("string"));
2522                                 isPropertyAppear = true;
2523                                 break;
2524                         case "string_prop17":
2525                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2526                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2527                                 assertTrue("Check entrySchema Property Type ",
2528                                                 pro.getSchema().getProperty().getType().equals("string"));
2529                                 isPropertyAppear = true;
2530                                 break;
2531                         case "string_prop18":
2532                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2533                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2534                                 assertTrue("Check entrySchema Property Type ",
2535                                                 pro.getSchema().getProperty().getType().equals("string"));
2536                                 isPropertyAppear = true;
2537                                 break;
2538                         case "string_prop19":
2539                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2540                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":\"AbcD\"}"));
2541                                 assertTrue("Check entrySchema Property Type ",
2542                                                 pro.getSchema().getProperty().getType().equals("string"));
2543                                 isPropertyAppear = true;
2544                                 break;
2545                         case "string_prop20":
2546                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2547                                 assertTrue("Check Property  default values ", pro.getDefaultValue()
2548                                                 .equals("{\"keyA\":\"aaaa\",\"keya\":\"aaaa\",\"Keya\":\"Aaaa\",\"KEYA\":\"nnnn\"}"));
2549                                 assertTrue("Check entrySchema Property Type ",
2550                                                 pro.getSchema().getProperty().getType().equals("string"));
2551                                 isPropertyAppear = true;
2552                                 break;
2553                         case "string_prop21":
2554                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2555                                 assertTrue("Check Property  default values ",
2556                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null}"));
2557                                 assertTrue("Check entrySchema Property Type ",
2558                                                 pro.getSchema().getProperty().getType().equals("string"));
2559                                 isPropertyAppear = true;
2560                                 break;
2561                         case "string_prop22":
2562                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2563                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2564                                 assertTrue("Check entrySchema Property Type ",
2565                                                 pro.getSchema().getProperty().getType().equals("string"));
2566                                 isPropertyAppear = true;
2567                                 break;
2568                         case "integer_prop01":
2569                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2570                                 assertTrue("Check Property  default values ",
2571                                                 pro.getDefaultValue().equals("{\"keyA\":1,\"keyB\":1000}"));
2572                                 assertTrue("Check entrySchema Property Type ",
2573                                                 pro.getSchema().getProperty().getType().equals("integer"));
2574                                 isPropertyAppear = true;
2575                                 break;
2576                         case "integer_prop02":
2577                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2578                                 assertTrue("Check Property  default values ",
2579                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null}"));
2580                                 assertTrue("Check entrySchema Property Type ",
2581                                                 pro.getSchema().getProperty().getType().equals("integer"));
2582                                 isPropertyAppear = true;
2583                                 break;
2584                         case "integer_prop03":
2585                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2586                                 assertTrue("Check Property  default values ",
2587                                                 pro.getDefaultValue().equals("{\"keyA\":800,\"keyB\":-600}"));
2588                                 assertTrue("Check entrySchema Property Type ",
2589                                                 pro.getSchema().getProperty().getType().equals("integer"));
2590                                 isPropertyAppear = true;
2591                                 break;
2592                         case "integer_prop04":
2593                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2594                                 assertTrue("Check Property  default values ",
2595                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":-600}"));
2596                                 assertTrue("Check entrySchema Property Type ",
2597                                                 pro.getSchema().getProperty().getType().equals("integer"));
2598                                 isPropertyAppear = true;
2599                                 break;
2600                         case "integer_prop05":
2601                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2602                                 assertTrue("Check Property  default values ",
2603                                                 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":0}"));
2604                                 assertTrue("Check entrySchema Property Type ",
2605                                                 pro.getSchema().getProperty().getType().equals("integer"));
2606                                 isPropertyAppear = true;
2607                                 break;
2608                         case "integer_prop06":
2609                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2610                                 assertTrue("Check Property  default values ",
2611                                                 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":0}"));
2612                                 assertTrue("Check entrySchema Property Type ",
2613                                                 pro.getSchema().getProperty().getType().equals("integer"));
2614                                 isPropertyAppear = true;
2615                                 break;
2616                         case "integer_prop07":
2617                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2618                                 assertTrue("Check Property  default values ",
2619                                                 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":100}"));
2620                                 assertTrue("Check entrySchema Property Type ",
2621                                                 pro.getSchema().getProperty().getType().equals("integer"));
2622                                 isPropertyAppear = true;
2623                                 break;
2624                         case "integer_prop08":
2625                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2626                                 assertTrue("Check Property  default values ",
2627                                                 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":200}"));
2628                                 assertTrue("Check entrySchema Property Type ",
2629                                                 pro.getSchema().getProperty().getType().equals("integer"));
2630                                 isPropertyAppear = true;
2631                                 break;
2632                         case "integer_prop09":
2633                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2634                                 assertTrue("Check Property  default values ",
2635                                                 pro.getDefaultValue().equals("{\"keyA\":100,\"keyB\":200}"));
2636                                 assertTrue("Check entrySchema Property Type ",
2637                                                 pro.getSchema().getProperty().getType().equals("integer"));
2638                                 isPropertyAppear = true;
2639                                 break;
2640                         case "integer_prop10":
2641                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2642                                 assertTrue("Check Property  default values ",
2643                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":2222}"));
2644                                 assertTrue("Check entrySchema Property Type ",
2645                                                 pro.getSchema().getProperty().getType().equals("integer"));
2646                                 isPropertyAppear = true;
2647                                 break;
2648                         case "integer_prop11":
2649                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2650                                 assertTrue("Check Property  default values ",
2651                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2652                                 assertTrue("Check entrySchema Property Type ",
2653                                                 pro.getSchema().getProperty().getType().equals("integer"));
2654                                 isPropertyAppear = true;
2655                                 break;
2656                         case "integer_prop12":
2657                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2658                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2659                                 assertTrue("Check entrySchema Property Type ",
2660                                                 pro.getSchema().getProperty().getType().equals("integer"));
2661                                 isPropertyAppear = true;
2662                                 break;
2663                         case "integer_prop13":
2664                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2665                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":200}"));
2666                                 assertTrue("Check entrySchema Property Type ",
2667                                                 pro.getSchema().getProperty().getType().equals("integer"));
2668                                 isPropertyAppear = true;
2669                                 break;
2670                         case "boolean_prop01":
2671                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2672                                 assertTrue("Check Property  default values ",
2673                                                 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false,\"keyC\":false}"));
2674                                 assertTrue("Check entrySchema Property Type ",
2675                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2676                                 isPropertyAppear = true;
2677                                 break;
2678                         case "boolean_prop02":
2679                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2680                                 assertTrue("Check Property  default values ",
2681                                                 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false,\"keyC\":false}"));
2682                                 assertTrue("Check entrySchema Property Type ",
2683                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2684                                 isPropertyAppear = true;
2685                                 break;
2686                         case "boolean_prop03":
2687                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2688                                 assertTrue("Check Property  default values ",
2689                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2690                                 assertTrue("Check entrySchema Property Type ",
2691                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2692                                 isPropertyAppear = true;
2693                                 break;
2694                         case "boolean_prop04":
2695                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2696                                 assertTrue("Check Property  default values ",
2697                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2698                                 assertTrue("Check entrySchema Property Type ",
2699                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2700                                 isPropertyAppear = true;
2701                                 break;
2702                         case "boolean_prop05":
2703                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2704                                 assertTrue("Check Property  default values ",
2705                                                 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false,\"keyC\":false}"));
2706                                 assertTrue("Check entrySchema Property Type ",
2707                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2708                                 isPropertyAppear = true;
2709                                 break;
2710                         case "boolean_prop06":
2711                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2712                                 assertTrue("Check Property  default values ",
2713                                                 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":true,\"keyC\":false}"));
2714                                 assertTrue("Check entrySchema Property Type ",
2715                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2716                                 isPropertyAppear = true;
2717                                 break;
2718                         case "boolean_prop07":
2719                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2720                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2721                                 assertTrue("Check entrySchema Property Type ",
2722                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2723                                 isPropertyAppear = true;
2724                                 break;
2725                         case "boolean_prop08":
2726                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2727                                 assertTrue("Check Property  default values ",
2728                                                 pro.getDefaultValue().equals("{\"keyA\":true,\"keyB\":false}"));
2729                                 assertTrue("Check entrySchema Property Type ",
2730                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2731                                 isPropertyAppear = true;
2732                                 break;
2733                         case "boolean_prop09":
2734                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2735                                 assertTrue("Check Property  default values ",
2736                                                 pro.getDefaultValue().equals("{\"keyA\":false,\"keyB\":true}"));
2737                                 assertTrue("Check entrySchema Property Type ",
2738                                                 pro.getSchema().getProperty().getType().equals("boolean"));
2739                                 isPropertyAppear = true;
2740                                 break;
2741                         case "float_prop01":
2742                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2743                                 assertTrue("Check Property  default values ",
2744                                                 pro.getDefaultValue().equals("{\"keyA\":1.2,\"keyB\":3.56,\"keyC\":33}"));
2745                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2746                                 isPropertyAppear = true;
2747                                 break;
2748                         case "float_prop02":
2749                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2750                                 assertTrue("Check Property  default values ",
2751                                                 pro.getDefaultValue().equals("{\"keyA\":0.0,\"keyB\":0.0,\"keyC\":0}"));
2752                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2753                                 isPropertyAppear = true;
2754                                 break;
2755                         case "float_prop03":
2756                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2757                                 assertTrue("Check Property  default values ",
2758                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2759                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2760                                 isPropertyAppear = true;
2761                                 break;
2762                         case "float_prop04":
2763                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2764                                 assertTrue("Check Property  default values ",
2765                                                 pro.getDefaultValue().equals("{\"keyA\":1.2,\"keyB\":3.56,\"keyC\":33}"));
2766                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2767                                 isPropertyAppear = true;
2768                                 break;
2769                         case "float_prop05":
2770                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2771                                 assertTrue("Check Property  default values ",
2772                                                 pro.getDefaultValue().equals("{\"keyA\":33,\"keyB\":1.2,\"keyC\":3.607,\"keyD\":0}"));
2773                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2774                                 isPropertyAppear = true;
2775                                 break;
2776                         case "float_prop06":
2777                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2778                                 assertTrue("Check Property  default values ",
2779                                                 pro.getDefaultValue().equals("{\"keyA\":33,\"keyB\":1.2,\"keyC\":3.607}"));
2780                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2781                                 isPropertyAppear = true;
2782                                 break;
2783                         case "float_prop07":
2784                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2785                                 assertTrue("Check Property  default values ",
2786                                                 pro.getDefaultValue().equals("{\"keyA\":null,\"keyB\":null,\"keyC\":null,\"keyD\":null}"));
2787                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2788                                 isPropertyAppear = true;
2789                                 break;
2790                         case "float_prop08":
2791                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2792                                 assertEquals("Check Property  default values ", pro.getDefaultValue(), null);
2793                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2794                                 isPropertyAppear = true;
2795                                 break;
2796                         case "float_prop09":
2797                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2798                                 assertTrue("Check Property  default values ",
2799                                                 pro.getDefaultValue().equals("{\"keyA\":0.01,\"keyB\":null}"));
2800                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2801                                 isPropertyAppear = true;
2802                                 break;
2803                         case "float_prop10":
2804                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2805                                 assertTrue("Check Property  default values ", pro.getDefaultValue().equals("{\"keyA\":0.00020}"));
2806                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2807                                 isPropertyAppear = true;
2808                                 break;
2809                         case "float_prop11":
2810                                 assertTrue("Check Property Type ", pro.getType().equals("map"));
2811                                 assertTrue("Check Property  default values ",
2812                                                 pro.getDefaultValue().equals("{\"keyA\":3.56,\"keyB\":33}"));
2813                                 assertTrue("Check entrySchema Property Type ", pro.getSchema().getProperty().getType().equals("float"));
2814                                 isPropertyAppear = true;
2815                                 break;
2816                         }
2817                         assertTrue(isPropertyAppear);
2818                         isPropertyAppear = false;
2819                 }
2820
2821         }
2822
2823         @Test
2824         public void importToscaResourceAttributeSuccessFlow() throws Exception {
2825
2826                 String fileName = importAttributeSuccess;
2827                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
2828                                 fileName);
2829                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, sdncUserDetails,
2830                                 null);
2831                 ResourceRestUtils.checkCreateResponse(importResourceResponse);
2832                 Resource resourceJavaObject = ResponseParser
2833                                 .convertResourceResponseToJavaObject(importResourceResponse.getResponse());
2834                 ToscaNodeTypeInfo parseToscaNodeYaml = utils
2835                                 .parseToscaNodeYaml(Decoder.decode(importReqDetails.getPayloadData()));
2836
2837                 HashMap<String, PropertyDefinition> attr = new HashMap<>();
2838
2839                 PropertyDefinition newAttr2 = new PropertyDefinition();
2840                 newAttr2.setName("networks");
2841                 newAttr2.setType("map");
2842                 newAttr2.setDefaultValue("{\"keyA\" : val1 , \"keyB\" : val2}");
2843                 SchemaDefinition schema = new SchemaDefinition();
2844                 PropertyDataDefinition prop = new PropertyDataDefinition();
2845                 prop.setType("string");
2846                 schema.setProperty(prop);
2847                 newAttr2.setSchema(schema);
2848                 attr.put("networks", newAttr2);
2849
2850                 PropertyDefinition newAttr1 = new PropertyDefinition();
2851                 newAttr1.setName("public_address");
2852                 newAttr1.setType("string");
2853                 attr.put("public_address", newAttr1);
2854
2855                 PropertyDefinition newAttr3 = new PropertyDefinition();
2856                 newAttr3.setName("ports");
2857                 newAttr3.setDescription("this is my description");
2858                 attr.put("ports", newAttr3);
2859
2860                 PropertyDefinition newAttr = new PropertyDefinition();
2861                 newAttr.setDefaultValue("myDefault");
2862                 newAttr.setName("private_address");
2863                 newAttr.setStatus("supported");
2864                 newAttr.setType("string");
2865                 attr.put("private_address", newAttr);
2866
2867                 // verify Resource Attributes
2868                 validateResourceAttribute(resourceJavaObject, attr);
2869
2870                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory
2871                                 .getDefaultImportResourceAuditMsgSuccess();
2872                 expectedResourceAuditJavaObject.setResourceName(importReqDetails.getName());
2873                 expectedResourceAuditJavaObject.setModifierName(sdncUserDetails.getFullName());
2874                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
2875                 expectedResourceAuditJavaObject.setToscaNodeType(parseToscaNodeYaml.getNodeName());
2876                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
2877                                 AuditingActionEnum.IMPORT_RESOURCE.getName(), null, false);
2878         }
2879
2880         private void validateResourceAttribute(Resource resource, Map<String, PropertyDefinition> attr) {
2881                 List<PropertyDefinition> resList = resource.getAttributes();
2882                 int size = resList.size();
2883                 String attributeName;
2884                 for (int i = 0; i < size; i++) {
2885                         attributeName = resList.get(i).getName();
2886                         assertEquals(attr.get(attributeName).getDefaultValue(), resList.get(i).getDefaultValue());
2887                         assertEquals(attr.get(attributeName).getName(), resList.get(i).getName());
2888                         assertEquals(attr.get(attributeName).getDescription(), resList.get(i).getDescription());
2889                         assertEquals(attr.get(attributeName).getStatus(), resList.get(i).getStatus());
2890                 }
2891         }
2892
2893 }