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