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