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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.imports;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import java.io.IOException;
  29 import java.util.ArrayList;
  30 import java.util.Arrays;
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34
  35 import org.apache.commons.codec.binary.Base64;
  36 import org.apache.http.HttpStatus;
  37 import org.junit.Rule;
  38 import org.junit.rules.TestName;
  39 import org.openecomp.sdc.be.dao.api.ActionStatus;
  40 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  41 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  42 import org.openecomp.sdc.be.model.PropertyDefinition;
  43 import org.openecomp.sdc.be.model.Resource;
  44 import org.openecomp.sdc.be.model.User;
  45 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  46 import org.openecomp.sdc.ci.tests.api.Urls;
  47 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  48 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
  49 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  50 import org.openecomp.sdc.ci.tests.datatypes.enums.ImportTestTypesEnum;
  51 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  55 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  56 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  57 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  58 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  59 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
  60 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  61 import org.openecomp.sdc.ci.tests.utils.rest.ImportRestUtils;
  62 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  63 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  64 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  65 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  66 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  67 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
  68 import org.openecomp.sdc.common.api.Constants;
  69 import org.openecomp.sdc.common.util.GeneralUtility;
  70 import org.testng.annotations.BeforeMethod;
  71 import org.testng.annotations.Test;
  72
  73 import com.google.gson.Gson;
  74
  75 public class ImportNewResourceCITest extends ComponentBaseTest {
  76
  77         // public static UserUtils userUtils = new UserUtils();
  78         // public ResourceUtils resourceUtils = new ResourceUtils();
  79         // public AuditValidationUtils AuditValidationUtils = new
  80         // AuditValidationUtils();
  81         // protected ArtifactUtils artifactUtils = new ArtifactUtils();
  82
  83         protected String resourceVersion = null;
  84         protected String auditAction = null;
  85         public User sdncModifierDetails = new User();
  86         protected String artifactName1 = "data_artifact1.sh";
  87         protected String artifactName2 = "data_artifact2.sh";
  88         protected String interfaze = "standard";
  89         protected String interfaceArtifactName = "data_interface1.sh";
  90
  91         private String SPECIAL_CHARACTERS = "~!#@~$%^*()[];:'\"|\\/";
  92
  93         public ResourceReqDetails resourceDetails = new ResourceReqDetails();
  94
  95         public Gson gson = new Gson();
  96
  97         @Rule
  98         public static TestName name = new TestName();
  99
 100         public ImportNewResourceCITest() {
 101                 super(name, ImportNewResourceCITest.class.getName());
 102         }
 103
 104         @BeforeMethod
 105         public void before() throws Exception {
 106
 107                 // init user
 108                 sdncModifierDetails.setUserId(UserRoleEnum.ADMIN.getUserId());
 109                 // init resource details
 110                 resourceDetails = ElementFactory.getDefaultResource("importResource4test", NormativeTypesEnum.ROOT,
 111                                 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, "jh0003");
 112         }
 113
 114         @Test
 115         public void importAllTestResources_toValidateNewAPI() throws Exception {
 116
 117                 for (ImportTestTypesEnum currResource : ImportTestTypesEnum.values()) {
 118                         // clean audit
 119                         DbUtils.cleanAllAudits();
 120
 121                         // import testResources trough newResource API
 122                         RestResponse importResponse = ImportRestUtils.importNewResourceByName(currResource.getFolderName(),
 123                                         UserRoleEnum.ADMIN);
 124                         System.err.println("import Resource " + "<" + currResource.getFolderName() + ">" + "response: "
 125                                         + importResponse.getErrorCode());
 126
 127                         // validate response
 128                         ImportRestUtils.validateImportTestTypesResp(currResource, importResponse);
 129                         if (currResource.getvalidateAudit() == true) {
 130                                 // validate audit
 131                                 // String baseVersion="0.1";
 132                                 String baseVersion = "";
 133                                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(currResource.getActionStatus().name());
 134                                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
 135                                 String auditAction = "ResourceImport";
 136                                 expectedResourceAuditJavaObject.setAction(auditAction);
 137                                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.ADMIN.getUserId());
 138                                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.ADMIN.getUserName());
 139                                 expectedResourceAuditJavaObject.setResourceName(currResource.getNormativeName());
 140                                 expectedResourceAuditJavaObject.setResourceType("Resource");
 141                                 expectedResourceAuditJavaObject.setPrevVersion("");
 142                                 expectedResourceAuditJavaObject.setCurrVersion(baseVersion);
 143                                 expectedResourceAuditJavaObject.setPrevState("");
 144                                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 145                                 expectedResourceAuditJavaObject.setCurrState("");
 146                                 expectedResourceAuditJavaObject.setComment(null);
 147                                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 148                                 List<String> variables = (currResource.getErrorParams() != null ? currResource.getErrorParams()
 149                                                 : new ArrayList<String>());
 150                                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 151                                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 152                                 AuditValidationUtils.validateAuditImport(expectedResourceAuditJavaObject, auditAction);
 153                         }
 154                 }
 155         }
 156
 157         protected RestResponse importNewResource(UserRoleEnum userRoleEnum) throws Exception {
 158
 159                 // init user
 160                 sdncModifierDetails.setUserId(userRoleEnum.getUserId());
 161                 // init resource details
 162                 resourceDetails = ElementFactory.getDefaultResource("importResource4test", NormativeTypesEnum.ROOT,
 163                                 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, "jh0003");
 164                 // clean ES DB
 165                 DbUtils.cleanAllAudits();
 166                 // import new resource (expected checkOut state)
 167                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4test", userRoleEnum);
 168                 return importResponse;
 169         }
 170
 171         @Test(enabled = false)
 172         public void importUIResource() throws IOException {
 173                 String payload = "tosca_definitions_version: tosca_simple_yaml_1_0_0\r\n" + "node_types: \r\n"
 174                                 + "  org.openecomp.resource.importResource4test:\r\n" + "    derived_from: tosca.nodes.Root\r\n"
 175                                 + "    description: someDesc";
 176
 177                 String encodedPayload = new String(Base64.encodeBase64(payload.getBytes()));
 178
 179                 String json = "{\r\n" + "  \"resourceName\": \"importResource4test\",\r\n"
 180                                 + "  \"payloadName\": \"importResource4test.yml\",\r\n"
 181                                 + "  \"categories\": [{\"name\": \"Application L4+\",\"normalizedName\": \"application l4+\",\"uniqueId\": \"resourceNewCategory.application l4+\",\"subcategories\": [{\"name\": \"Web Server\"}]}],\r\n"
 182                                 + "  \"description\": \"ResourceDescription\",\r\n" + "  \"vendorName\": \"VendorName\",\r\n"
 183                                 + "  \"vendorRelease\": \"VendorRelease\",\r\n" + "  \"contactId\": \"AT1234\",\r\n"
 184                                 + "  \"icon\": \"router\",\r\n" + "  \"tags\": [\r\n" + "    \"importResource4test\"\r\n" + "  ],\r\n"
 185                                 + "  \"payloadData\": \"" + encodedPayload + "\"\r\n" + "}";
 186
 187                 String md5 = GeneralUtility.calculateMD5ByString(json);
 188
 189                 Map<String, String> headers = new HashMap<String, String>();
 190                 headers.put(Constants.MD5_HEADER, md5);
 191                 headers.put(Constants.USER_ID_HEADER, UserRoleEnum.ADMIN.getUserId());
 192                 headers.put(Constants.CONTENT_TYPE_HEADER, "application/json");
 193
 194                 String url = String.format(Urls.CREATE_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort());
 195
 196                 HttpRequest httpUtil = new HttpRequest();
 197                 RestResponse httpSendPost = httpUtil.httpSendPost(url, json, headers);
 198                 Integer errorCode = httpSendPost.getErrorCode();
 199                 assertTrue(errorCode == HttpStatus.SC_CREATED);
 200
 201         }
 202
 203         // TODO DE171337
 204         @Test(enabled = false)
 205         public void importNewResource_suc() throws Exception {
 206
 207                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 208
 209                 assertNotNull("check response object is not null after import resource", importResponse);
 210                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 211                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 212
 213                 // validate response
 214
 215                 resourceVersion = "0.1";
 216
 217                 // ResourceRespJavaObject resourceRespJavaObject =
 218                 // Convertor.constructFieldsForRespValidation(resourceDetails,
 219                 // resourceVersion);
 220                 // resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 221                 // ResourceValidationUtils.validateResp(importResponse,
 222                 // resourceRespJavaObject);
 223                 //
 224                 // //validate get response
 225                 //
 226                 // RestResponse resourceGetResponse =
 227                 // ResourceRestUtils.getResource(sdncModifierDetails, resourceVersion);
 228                 // ResourceValidationUtils.validateResp(resourceGetResponse,
 229                 // resourceRespJavaObject);
 230                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 231                 assertNotNull(resourceFromImport);
 232
 233                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 234                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails);
 235                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 236
 237                 // validate get response
 238                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 239                                 resourceRespJavaObject.getUniqueId());
 240                 Resource resourceFromGet = ResponseParser
 241                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 242                 assertNotNull(resourceFromGet);
 243
 244                 // validate
 245                 ResourceValidationUtils.validateModelObjects(resourceFromImport, resourceFromGet);
 246
 247                 // validate audit
 248                 resourceDetails.setVersion(resourceDetails.getVersion());
 249                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 250                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 251
 252                 auditAction = "ResourceImport";
 253                 expectedResourceAuditJavaObject.setAction(auditAction);
 254                 expectedResourceAuditJavaObject.setPrevState("");
 255                 expectedResourceAuditJavaObject.setPrevVersion("");
 256                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 257                 expectedResourceAuditJavaObject.setStatus("201");
 258                 expectedResourceAuditJavaObject.setDesc("OK");
 259                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
 260                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 261
 262         }
 263
 264         @Test
 265         public void importNewResource_byTester_failed() throws Exception {
 266
 267                 RestResponse importResponse = importNewResource(UserRoleEnum.TESTER);
 268
 269                 assertNotNull("check response object is not null after import resource", importResponse);
 270                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 271                 assertEquals("Check response code after import resource", 409, importResponse.getErrorCode().intValue());
 272
 273         }
 274
 275         // TODO DE171337
 276         @Test(enabled = false)
 277         public void importNewResource_existInCheckout_updateVendorName_updateCategory() throws Exception {
 278
 279                 // import new resource
 280                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 281
 282                 assertNotNull("check response object is not null after import resource", importResponse);
 283                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 284                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 285
 286                 // clean audit
 287                 DbUtils.cleanAllAudits();
 288
 289                 // import new resource while resource already exist in other state
 290                 importResponse = ImportRestUtils.importNewResourceByName("importResource4testUpdateVendorNameAndCategory",
 291                                 UserRoleEnum.ADMIN);
 292
 293                 assertNotNull("check response object is not null after import resource", importResponse);
 294                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 295                 assertEquals("Check response code after import resource", 200, importResponse.getErrorCode().intValue());
 296
 297                 // validate response
 298                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 299                 assertNotNull(resourceFromImport);
 300
 301                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 302                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails);
 303                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 304
 305                 // validate get response
 306                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 307                                 resourceRespJavaObject.getUniqueId());
 308                 Resource resourceFromGet = ResponseParser
 309                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 310                 assertNotNull(resourceFromGet);
 311
 312                 // validate
 313                 ResourceValidationUtils.validateModelObjects(resourceFromImport, resourceFromGet);
 314
 315                 // validate audit
 316                 resourceDetails.setVersion(resourceDetails.getVersion());
 317                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 318                                 .constructFieldsForAuditValidation(resourceDetails);
 319
 320                 auditAction = "ResourceImport";
 321                 resourceVersion = "0.1";
 322                 expectedResourceAuditJavaObject.setAction(auditAction);
 323                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 324                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 325                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
 326                 expectedResourceAuditJavaObject.setStatus("200");
 327                 expectedResourceAuditJavaObject.setDesc("OK");
 328                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
 329                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 330         }
 331
 332         @Test
 333         public void importNewResource_perfromByAdmin_ownedBy_diffrentUser() throws Exception {
 334
 335                 RestResponse importResponse = importNewResource(UserRoleEnum.DESIGNER);
 336
 337                 assertNotNull("check response object is not null after import resource", importResponse);
 338                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 339                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 340
 341                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 342                 // clean audit
 343                 DbUtils.cleanAllAudits();
 344
 345                 importResponse = importNewResource(UserRoleEnum.ADMIN);
 346
 347                 assertNotNull("check response object is not null after import resource", importResponse);
 348                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 349
 350                 ErrorInfo errorInfo = ErrorValidationUtils
 351                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CHECKOUT_STATE.name());
 352                 assertEquals("Check response code after adding artifact", errorInfo.getCode(), importResponse.getErrorCode());
 353
 354                 String[] split = resourceFromImport.getLastUpdaterFullName().split(" ");
 355                 String firstName = split[0];
 356                 String lastName = split[1];
 357                 List<String> variables = Arrays.asList(resourceFromImport.getName(), "resource", firstName, lastName,
 358                                 resourceFromImport.getLastUpdaterUserId());
 359                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_IN_CHECKOUT_STATE.name(), variables,
 360                                 importResponse.getResponse());
 361
 362         }
 363
 364         @Test
 365         public void importNewResource_perfromByDesigner_ownedBy_diffrentUser() throws Exception {
 366
 367                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 368
 369                 assertNotNull("check response object is not null after import resource", importResponse);
 370                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 371                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 372                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 373                 // clean audit
 374                 DbUtils.cleanAllAudits();
 375
 376                 importResponse = importNewResource(UserRoleEnum.DESIGNER);
 377
 378                 assertNotNull("check response object is not null after import resource", importResponse);
 379                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 380
 381                 ErrorInfo errorInfo = ErrorValidationUtils
 382                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CHECKOUT_STATE.name());
 383                 assertEquals("Check response code after adding artifact", errorInfo.getCode(), importResponse.getErrorCode());
 384
 385                 String[] split = resourceFromImport.getLastUpdaterFullName().split(" ");
 386                 String firstName = split[0];
 387                 String lastName = split[1];
 388                 List<String> variables = Arrays.asList(resourceFromImport.getName(), "resource", firstName, lastName,
 389                                 resourceFromImport.getLastUpdaterUserId());
 390                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_IN_CHECKOUT_STATE.name(), variables,
 391                                 importResponse.getResponse());
 392
 393         }
 394
 395         @Test(enabled = false)
 396         public void importNewResource_nameSpace_vf() throws Exception {
 397                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4testVF",
 398                                 UserRoleEnum.DESIGNER);
 399                 assertNotNull("check response object is not null after import resource", importResponse);
 400                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 401                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 402                 Resource resourceRespJavaObject = ResponseParser
 403                                 .convertResourceResponseToJavaObject(importResponse.getResponse());
 404                 assertTrue(resourceRespJavaObject.getResourceType().equals(ResourceTypeEnum.VF));
 405
 406         }
 407
 408         @Test
 409         public void importNewResource_nameSpace_vfc() throws Exception {
 410                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4testVFC",
 411                                 UserRoleEnum.DESIGNER);
 412                 assertNotNull("check response object is not null after import resource", importResponse);
 413                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 414                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 415                 Resource resourceRespJavaObject = ResponseParser
 416                                 .convertResourceResponseToJavaObject(importResponse.getResponse());
 417                 assertTrue(resourceRespJavaObject.getResourceType().equals(ResourceTypeEnum.VFC));
 418         }
 419
 420         @Test
 421         public void importNewResource_nameSpace_vl() throws Exception {
 422                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4testVL",
 423                                 UserRoleEnum.DESIGNER);
 424                 assertNotNull("check response object is not null after import resource", importResponse);
 425                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 426                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 427                 Resource resourceRespJavaObject = ResponseParser
 428                                 .convertResourceResponseToJavaObject(importResponse.getResponse());
 429                 assertTrue(resourceRespJavaObject.getResourceType().equals(ResourceTypeEnum.VL));
 430
 431         }
 432
 433         @Test
 434         public void importNewResource_nameSpace_cp() throws Exception {
 435                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4testCP",
 436                                 UserRoleEnum.DESIGNER);
 437                 assertNotNull("check response object is not null after import resource", importResponse);
 438                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 439                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 440
 441                 Resource resourceRespJavaObject = ResponseParser
 442                                 .convertResourceResponseToJavaObject(importResponse.getResponse());
 443                 assertTrue(resourceRespJavaObject.getResourceType().equals(ResourceTypeEnum.CP));
 444         }
 445
 446         @Test
 447         public void importNewResource_nameSpace_unknown() throws Exception {
 448                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4test",
 449                                 UserRoleEnum.DESIGNER);
 450                 assertNotNull("check response object is not null after import resource", importResponse);
 451                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 452                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 453                 Resource resourceRespJavaObject = ResponseParser
 454                                 .convertResourceResponseToJavaObject(importResponse.getResponse());
 455                 assertTrue(resourceRespJavaObject.getResourceType().equals(ResourceTypeEnum.VFC));
 456
 457         }
 458
 459         @Test
 460         public void importNewResource_MissingNameSpace() throws Exception {
 461                 RestResponse importResponse = ImportRestUtils.importNewResourceByName("importResource4testMissingNameSpace",
 462                                 UserRoleEnum.DESIGNER);
 463                 assertNotNull("check response object is not null after import resource", importResponse);
 464                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 465                 assertEquals("Check response code after import resource", 400, importResponse.getErrorCode().intValue());
 466
 467         }
 468
 469         // TODO DE171337
 470         @Test(enabled = false)
 471         public void importNewResource_existInCheckOut() throws Exception {
 472
 473                 // import new resource
 474
 475                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 476
 477                 assertNotNull("check response object is not null after import resource", importResponse);
 478                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 479                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 480
 481                 // clean audit
 482                 DbUtils.cleanAllAudits();
 483
 484                 // import new resource while resource already exist in CHECKOUT state
 485
 486                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.ADMIN);
 487
 488                 assertNotNull("check response object is not null after import resource", importResponse);
 489                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 490                 assertEquals("Check response code after import resource", 200, importResponse.getErrorCode().intValue());
 491
 492                 // validate response
 493                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 494                 assertNotNull(resourceFromImport);
 495                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 496                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails);
 497                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 498
 499                 // validate get response
 500                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 501                                 resourceRespJavaObject.getUniqueId());
 502                 Resource resourceFromGet = ResponseParser
 503                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 504                 assertNotNull(resourceFromGet);
 505
 506                 // validate
 507                 ResourceValidationUtils.validateModelObjects(resourceFromImport, resourceFromGet);
 508
 509                 // validate audit
 510                 resourceDetails.setVersion(resourceDetails.getVersion());
 511                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 512                                 .constructFieldsForAuditValidation(resourceDetails);
 513
 514                 auditAction = "ResourceImport";
 515                 resourceVersion = "0.1";
 516                 expectedResourceAuditJavaObject.setAction(auditAction);
 517                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 518                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 519                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
 520                 expectedResourceAuditJavaObject.setStatus("200");
 521                 expectedResourceAuditJavaObject.setDesc("OK");
 522                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
 523
 524                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 525         }
 526
 527         // TODO DE171337
 528         @Test(enabled = false)
 529         public void importNewResource_existIn_CheckIn_state() throws Exception {
 530
 531                 // import new resource
 532
 533                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 534
 535                 assertNotNull("check response object is not null after import resource", importResponse);
 536                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 537                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 538                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 539                 // checkIn resource
 540
 541                 resourceVersion = resourceDetails.getVersion();
 542                 String checkinComment = "good checkin";
 543                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
 544                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 545                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
 546
 547                 assertNotNull("check response object is not null after import resource", checkInResponse);
 548                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
 549
 550                 // clean audit
 551                 DbUtils.cleanAllAudits();
 552
 553                 // import new resource while resource already exist in CHECKIN state
 554
 555                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.ADMIN);
 556
 557                 assertNotNull("check response object is not null after import resource", importResponse);
 558                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 559                 assertEquals("Check response code after import resource", 200, importResponse.getErrorCode().intValue());
 560
 561                 // validate response
 562                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 563                 assertNotNull(resourceFromImport);
 564
 565                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 566                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails);
 567                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 568
 569                 // validate get response
 570                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 571                                 resourceRespJavaObject.getUniqueId());
 572                 Resource resourceFromGet = ResponseParser
 573                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 574                 assertNotNull(resourceFromGet);
 575
 576                 // validate
 577                 ResourceValidationUtils.validateModelObjects(resourceFromImport, resourceFromGet);
 578
 579                 // validate audit
 580                 resourceDetails.setVersion(resourceDetails.getVersion());
 581                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 582                                 .constructFieldsForAuditValidation(resourceDetails);
 583
 584                 resourceVersion = "0.2";
 585                 auditAction = "ResourceImport";
 586                 expectedResourceAuditJavaObject.setAction(auditAction);
 587                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 588                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 589                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
 590                 expectedResourceAuditJavaObject.setStatus("200");
 591                 expectedResourceAuditJavaObject.setDesc("OK");
 592                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
 593                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 594         }
 595
 596         @Test
 597         public void importNewResource_existIn_Ready4cert_state_performByTester() throws Exception {
 598                 // import new resource
 599
 600                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 601
 602                 assertNotNull("check response object is not null after import resource", importResponse);
 603                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 604                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 605
 606                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 607                 resourceVersion = resourceDetails.getVersion();
 608                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 609                                 resourceDetails.getUniqueId());
 610                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 611                 Resource resourceFromGet = ResponseParser
 612                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 613                 assertNotNull(resourceFromGet);
 614                 // add mandatory artifacts
 615                 // // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
 616                 // resourceGetResponse);
 617                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
 618                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 619                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 620                 assertNotNull(resourceFromGet);
 621                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 622                 resourceDetails.setVersion(resourceFromGet.getVersion());
 623
 624                 // checkIn resource
 625                 resourceVersion = resourceDetails.getVersion();
 626                 String checkinComment = "good checkin";
 627                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
 628                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 629                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
 630
 631                 assertNotNull("check response object is not null after import resource", checkInResponse);
 632                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
 633                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(checkInResponse.getResponse());
 634                 assertNotNull(resourceFromGet);
 635                 resourceDetails = ResponseParser.parseToObject(checkInResponse.getResponse(), ResourceReqDetails.class);
 636                 resourceDetails.setVersion(resourceFromGet.getVersion());
 637
 638                 // req4cert resource
 639                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 640                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 641                 assertNotNull("check response object is not null after resource request for certification", request4cert);
 642                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
 643                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
 644                 assertNotNull(resourceFromGet);
 645                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
 646                 resourceDetails.setVersion(resourceFromGet.getVersion());
 647
 648                 // clean audit
 649                 DbUtils.cleanAllAudits();
 650
 651                 // import new resource while resource already exist in CHECKIN state
 652                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.TESTER);
 653
 654                 // validate response
 655                 resourceVersion = resourceDetails.getVersion();
 656                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 657                 assertNotNull("check response object is not null after create resouce", importResponse);
 658                 assertNotNull("check error code exists in response after create resource", importResponse.getErrorCode());
 659                 assertEquals("Check response code after create service", errorInfo.getCode(), importResponse.getErrorCode());
 660                 List<String> variables = Arrays.asList();
 661                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), variables,
 662                                 importResponse.getResponse());
 663
 664                 // validate audit
 665
 666                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 667                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 668
 669                 String auditAction = "ResourceImport";
 670                 expectedResourceAuditJavaObject.setAction(auditAction);
 671                 expectedResourceAuditJavaObject.setResourceName("");
 672                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.TESTER.getUserId());
 673                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.TESTER.getUserName());
 674                 expectedResourceAuditJavaObject.setPrevState("");
 675                 expectedResourceAuditJavaObject.setCurrState("");
 676                 expectedResourceAuditJavaObject.setPrevVersion("");
 677                 expectedResourceAuditJavaObject.setCurrVersion("");
 678                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 679                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 680                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 681
 682                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 683         }
 684
 685         // TODO DE171337
 686         @Test(enabled = false)
 687         public void importNewResource_existIn_Ready4cert_state_performByDesigner() throws Exception {
 688                 // import new resource
 689
 690                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 691
 692                 assertNotNull("check response object is not null after import resource", importResponse);
 693                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 694                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 695
 696                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 697                 resourceVersion = resourceDetails.getVersion();
 698                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 699                                 resourceDetails.getUniqueId());
 700                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 701                 Resource resourceFromGet = ResponseParser
 702                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 703                 assertNotNull(resourceFromGet);
 704                 // add mandatory artifacts
 705                 // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
 706                 // resourceGetResponse);
 707                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
 708                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 709                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 710                 assertNotNull(resourceFromGet);
 711                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 712                 resourceDetails.setVersion(resourceFromGet.getVersion());
 713
 714                 // checkIn resource
 715                 resourceVersion = resourceDetails.getVersion();
 716                 String checkinComment = "good checkin";
 717                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
 718                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 719                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
 720                 assertNotNull("check response object is not null after import resource", checkInResponse);
 721                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
 722
 723                 // req4cert resource
 724                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 725                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 726                 assertNotNull("check response object is not null after resource request for certification", request4cert);
 727                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
 728                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
 729                 assertNotNull(resourceFromGet);
 730                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
 731                 resourceDetails.setVersion(resourceFromGet.getVersion());
 732
 733                 // clean audit
 734                 DbUtils.cleanAllAudits();
 735
 736                 // import new resource while resource already exist in other state
 737                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.DESIGNER);
 738
 739                 // validate response
 740                 ErrorInfo errorInfo = ErrorValidationUtils
 741                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_SENT_FOR_CERTIFICATION.name());
 742                 assertNotNull("check response object is not null after create resouce", importResponse);
 743                 assertNotNull("check error code exists in response after create resource", importResponse.getErrorCode());
 744                 assertEquals("Check response code after create service", errorInfo.getCode(), importResponse.getErrorCode());
 745                 String[] split = resourceFromGet.getLastUpdaterFullName().split(" ");
 746                 String firstName = split[0];
 747                 String lastName = split[1];
 748                 List<String> variables = Arrays.asList(resourceFromGet.getName(), "resource", firstName, lastName,
 749                                 resourceFromGet.getLastUpdaterUserId());
 750                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_SENT_FOR_CERTIFICATION.name(), variables,
 751                                 importResponse.getResponse());
 752
 753                 // validate audit
 754                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 755                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 756                 String auditAction = "ResourceImport";
 757                 expectedResourceAuditJavaObject.setAction(auditAction);
 758                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.DESIGNER.getUserId());
 759                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.DESIGNER.getUserName());
 760                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.READY_FOR_CERTIFICATION).toString());
 761                 // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 762                 expectedResourceAuditJavaObject.setCurrState("");
 763                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
 764                 expectedResourceAuditJavaObject.setCurrVersion("");
 765                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 766                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
 767                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 768                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 769                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 770
 771         }
 772
 773         // TODO DE171337
 774         @Test(enabled = false)
 775         public void importNewResource_existIn_Ready4cert_state_performByAdmin() throws Exception {
 776
 777                 // import new resource
 778                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 779                 assertNotNull("check response object is not null after import resource", importResponse);
 780                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 781                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 782                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 783                 resourceVersion = resourceDetails.getVersion();
 784                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 785                                 resourceDetails.getUniqueId());
 786                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 787                 Resource resourceFromGet = ResponseParser
 788                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 789                 assertNotNull(resourceFromGet);
 790
 791                 // add mandatory artifacts
 792                 // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
 793                 // resourceGetResponse);
 794                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
 795                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 796                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 797                 assertNotNull(resourceFromGet);
 798                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 799                 resourceDetails.setVersion(resourceFromGet.getVersion());
 800
 801                 // checkIn resource
 802                 resourceVersion = resourceDetails.getVersion();
 803                 String checkinComment = "good checkin";
 804                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
 805                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 806                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
 807                 assertNotNull("check response object is not null after import resource", checkInResponse);
 808                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
 809
 810                 // req4cert resource
 811                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 812                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 813                 assertNotNull("check response object is not null after resource request for certification", request4cert);
 814                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
 815                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
 816                 assertNotNull(resourceFromGet);
 817                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
 818                 resourceDetails.setVersion(resourceFromGet.getVersion());
 819
 820                 // clean audit
 821                 DbUtils.cleanAllAudits();
 822
 823                 // import new resource while resource already exist in other state
 824                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.ADMIN);
 825                 assertNotNull("check response object is not null after import resource", importResponse);
 826                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 827                 assertEquals("Check response code after import resource", 200, importResponse.getErrorCode().intValue());
 828                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 829                 assertNotNull(resourceFromGet);
 830                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
 831                 resourceDetails.setVersion(resourceFromGet.getVersion());
 832                 resourceVersion = resourceDetails.getVersion();
 833                 // resourceVersion="0.2";
 834
 835                 // validate response
 836                 Resource resourceFromImport = ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
 837                 assertNotNull(resourceFromImport);
 838                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 839                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails);
 840                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 841
 842                 // validate get response
 843                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceRespJavaObject.getUniqueId());
 844                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 845                 assertNotNull(resourceFromGet);
 846
 847                 // validate
 848                 ResourceValidationUtils.validateModelObjects(resourceFromImport, resourceFromGet);
 849
 850                 // validate audit
 851                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 852                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 853                 auditAction = "ResourceImport";
 854                 expectedResourceAuditJavaObject.setAction(auditAction);
 855                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 856                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 857                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
 858                 expectedResourceAuditJavaObject.setStatus("200");
 859                 expectedResourceAuditJavaObject.setDesc("OK");
 860                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
 861                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 862         }
 863
 864         @Test
 865         public void importNewResource_existIn_CerInProgress_state_performByTester() throws Exception {
 866
 867                 // import new resource
 868                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 869                 assertNotNull("check response object is not null after import resource", importResponse);
 870                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 871                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 872                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 873                 resourceVersion = resourceDetails.getVersion();
 874                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 875                                 resourceDetails.getUniqueId());
 876                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 877                 Resource resourceFromGet = ResponseParser
 878                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 879                 assertNotNull(resourceFromGet);
 880
 881                 // add mandatory artifacts
 882                 // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
 883                 // resourceGetResponse);
 884                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
 885                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 886                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 887                 assertNotNull(resourceFromGet);
 888                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 889                 resourceDetails.setVersion(resourceFromGet.getVersion());
 890
 891                 // checkIn resource
 892                 resourceVersion = resourceDetails.getVersion();
 893                 String checkinComment = "good checkin";
 894                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
 895                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 896                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
 897                 assertNotNull("check response object is not null after import resource", checkInResponse);
 898                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
 899
 900                 // req4cert resource
 901                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 902                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 903                 assertNotNull("check response object is not null after resource request for certification", request4cert);
 904                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
 905                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
 906                 assertNotNull(resourceFromGet);
 907                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
 908                 resourceDetails.setVersion(resourceFromGet.getVersion());
 909
 910                 // startCert
 911                 RestResponse startCert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 912                                 resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION);
 913                 assertNotNull("check response object is not null after resource request start certification", startCert);
 914                 assertEquals("Check response code after checkout resource", 200, startCert.getErrorCode().intValue());
 915                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(startCert.getResponse());
 916                 assertNotNull(resourceFromGet);
 917                 resourceDetails = ResponseParser.parseToObject(startCert.getResponse(), ResourceReqDetails.class);
 918                 resourceDetails.setVersion(resourceFromGet.getVersion());
 919
 920                 // clean audit
 921                 DbUtils.cleanAllAudits();
 922
 923                 // import new resource while resource already exist in other state
 924                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.TESTER);
 925
 926                 // validate response
 927                 resourceVersion = resourceDetails.getVersion();
 928                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 929                 assertNotNull("check response object is not null after create resouce", importResponse);
 930                 assertNotNull("check error code exists in response after create resource", importResponse.getErrorCode());
 931                 assertEquals("Check response code after create service", errorInfo.getCode(), importResponse.getErrorCode());
 932                 List<String> variables = Arrays.asList();
 933                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), variables,
 934                                 importResponse.getResponse());
 935
 936                 // validate audit
 937                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 938                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 939                 String auditAction = "ResourceImport";
 940                 expectedResourceAuditJavaObject.setAction(auditAction);
 941                 expectedResourceAuditJavaObject.setResourceName("");
 942                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.TESTER.getUserId());
 943                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.TESTER.getUserName());
 944                 expectedResourceAuditJavaObject.setPrevState("");
 945                 expectedResourceAuditJavaObject.setCurrState("");
 946                 expectedResourceAuditJavaObject.setPrevVersion("");
 947                 expectedResourceAuditJavaObject.setCurrVersion("");
 948                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 949                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 950                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 951                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 952         }
 953
 954         // TODO DE171337
 955         @Test(enabled = false)
 956         public void importNewResource_existIn_CerInProgress_state_performByDesigner() throws Exception {
 957
 958                 User sdncAdminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 959                 // import new resource
 960                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
 961                 assertNotNull("check response object is not null after import resource", importResponse);
 962                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
 963                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
 964                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 965                 resourceVersion = resourceDetails.getVersion();
 966                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 967                                 resourceDetails.getUniqueId());
 968                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 969                 Resource resourceFromGet = ResponseParser
 970                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 971                 assertNotNull(resourceFromGet);
 972
 973                 // add mandatory artifacts
 974                 // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
 975                 // resourceGetResponse);
 976                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
 977                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
 978                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 979                 assertNotNull(resourceFromGet);
 980                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
 981                 resourceDetails.setVersion(resourceFromGet.getVersion());
 982
 983                 // checkIn resource
 984                 resourceVersion = resourceDetails.getVersion();
 985                 String checkinComment = "good checkin";
 986                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
 987                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 988                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
 989                 assertNotNull("check response object is not null after import resource", checkInResponse);
 990                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
 991
 992                 // req4cert resource
 993                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
 994                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 995                 assertNotNull("check response object is not null after resource request for certification", request4cert);
 996                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
 997                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
 998                 assertNotNull(resourceFromGet);
 999                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
1000                 resourceDetails.setVersion(resourceFromGet.getVersion());
1001
1002                 // startCert
1003                 RestResponse startCert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1004                                 resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION);
1005                 assertNotNull("check response object is not null after resource request start certification", startCert);
1006                 assertEquals("Check response code after checkout resource", 200, startCert.getErrorCode().intValue());
1007                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(startCert.getResponse());
1008                 assertNotNull(resourceFromGet);
1009                 resourceDetails = ResponseParser.parseToObject(startCert.getResponse(), ResourceReqDetails.class);
1010                 resourceDetails.setVersion(resourceFromGet.getVersion());
1011                 resourceVersion = resourceDetails.getVersion();
1012
1013                 // clean audit
1014                 DbUtils.cleanAllAudits();
1015
1016                 // import new resource while resource already exist in other state
1017                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.DESIGNER);
1018                 ErrorInfo errorInfo = ErrorValidationUtils
1019                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
1020                 assertNotNull("check response object is not null after create resouce", importResponse);
1021                 assertNotNull("check error code exists in response after create resource", importResponse.getErrorCode());
1022                 assertEquals("Check response code after create service", errorInfo.getCode(), importResponse.getErrorCode());
1023                 List<String> variables = Arrays.asList(resourceDetails.getName(), "resource", sdncAdminUser.getFirstName(),
1024                                 sdncAdminUser.getLastName(), sdncAdminUser.getUserId());
1025                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name(),
1026                                 variables, importResponse.getResponse());
1027
1028                 // validate audit
1029                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1030                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
1031                 String auditAction = "ResourceImport";
1032                 expectedResourceAuditJavaObject.setAction(auditAction);
1033                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.DESIGNER.getUserId());
1034                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.DESIGNER.getUserName());
1035                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.CERTIFICATION_IN_PROGRESS).toString());
1036                 // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1037                 expectedResourceAuditJavaObject.setCurrState("");
1038                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
1039                 expectedResourceAuditJavaObject.setCurrVersion("");
1040                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1041                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
1042                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1043                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1044                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1045
1046         }
1047
1048         // TODO DE171337
1049         @Test(enabled = false)
1050         public void importNewResource_existIn_CerInProgress_state_performByAdmin() throws Exception {
1051
1052                 User sdncAdminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1053
1054                 // import new resource
1055                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
1056                 assertNotNull("check response object is not null after import resource", importResponse);
1057                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
1058                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
1059                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
1060                 resourceVersion = resourceDetails.getVersion();
1061                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
1062                                 resourceDetails.getUniqueId());
1063                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
1064                 Resource resourceFromGet = ResponseParser
1065                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1066                 assertNotNull(resourceFromGet);
1067
1068                 // add mandatory artifacts
1069                 // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
1070                 // resourceGetResponse);
1071                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
1072                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
1073                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1074                 assertNotNull(resourceFromGet);
1075                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
1076                 resourceDetails.setVersion(resourceFromGet.getVersion());
1077
1078                 // checkIn resource
1079                 resourceVersion = resourceDetails.getVersion();
1080                 String checkinComment = "good checkin";
1081                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
1082                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1083                                 resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
1084                 assertNotNull("check response object is not null after import resource", checkInResponse);
1085                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
1086
1087                 // req4cert resource
1088                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1089                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1090                 assertNotNull("check response object is not null after resource request for certification", request4cert);
1091                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
1092                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
1093                 assertNotNull(resourceFromGet);
1094                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
1095                 resourceDetails.setVersion(resourceFromGet.getVersion());
1096
1097                 // startCert
1098                 RestResponse startCert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1099                                 resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION);
1100                 assertNotNull("check response object is not null after resource request start certification", startCert);
1101                 assertEquals("Check response code after checkout resource", 200, startCert.getErrorCode().intValue());
1102                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(startCert.getResponse());
1103                 assertNotNull(resourceFromGet);
1104                 resourceDetails = ResponseParser.parseToObject(startCert.getResponse(), ResourceReqDetails.class);
1105                 resourceDetails.setVersion(resourceFromGet.getVersion());
1106                 resourceVersion = resourceDetails.getVersion();
1107
1108                 // clean audit
1109                 DbUtils.cleanAllAudits();
1110
1111                 // import new resource while resource already exist in other state
1112                 importResponse = ImportRestUtils.importNewResourceByName("importResource4test", UserRoleEnum.ADMIN);
1113
1114                 // validate response
1115                 ErrorInfo errorInfo = ErrorValidationUtils
1116                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
1117                 assertNotNull("check response object is not null after create resouce", importResponse);
1118                 assertNotNull("check error code exists in response after create resource", importResponse.getErrorCode());
1119                 assertEquals("Check response code after create service", errorInfo.getCode(), importResponse.getErrorCode());
1120                 List<String> variables = Arrays.asList(resourceDetails.getName(), "resource", sdncAdminUser.getFirstName(),
1121                                 sdncAdminUser.getLastName(), sdncAdminUser.getUserId());
1122                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name(),
1123                                 variables, importResponse.getResponse());
1124
1125                 // validate audit
1126                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1127                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
1128                 String auditAction = "ResourceImport";
1129                 expectedResourceAuditJavaObject.setAction(auditAction);
1130                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.ADMIN.getUserId());
1131                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.ADMIN.getUserName());
1132                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.CERTIFICATION_IN_PROGRESS).toString());
1133                 // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1134                 expectedResourceAuditJavaObject.setCurrState("");
1135                 expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
1136                 expectedResourceAuditJavaObject.setCurrVersion("");
1137                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1138                 expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
1139                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1140                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1141                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1142
1143         }
1144
1145         // TODO DE171337
1146         // @Test(enabled = false)
1147         // public void
1148         // importNewResource_existIn_Certified_state_chnage_reqAndCap_byDesigner()
1149         // throws Exception{
1150         //
1151         // // Andrey - set default artifact details
1152         // ArtifactDefinition artifactDefinition =
1153         // artifactUtils.constructDefaultArtifactInfo();
1154         //
1155         // // import new resource
1156         // RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
1157         // assertNotNull("check response object is not null after import resource",
1158         // importResponse);
1159         // assertNotNull("check error code exists in response after import
1160         // resource", importResponse.getErrorCode());
1161         // assertEquals("Check response code after import resource", 201,
1162         // importResponse.getErrorCode().intValue());
1163         // String resourceId =
1164         // ResponseParser.getUniqueIdFromResponse(importResponse);
1165         // resourceDetails =
1166         // ResponseParser.parseToObject(importResponse.getResponse(),
1167         // ResourceReqDetails.class);
1168         // resourceVersion = resourceDetails.getVersion();
1169         // RestResponse resourceGetResponse =
1170         // ResourceRestUtils.getResource(sdncModifierDetails,
1171         // resourceDetails.getUniqueId());
1172         // assertEquals("Check response code after get resource", 200,
1173         // resourceGetResponse.getErrorCode().intValue());
1174         // Resource resourceFromGet =
1175         // ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1176         // assertNotNull(resourceFromGet);
1177         //
1178         // // add mandatory artifacts
1179         // // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
1180         // resourceGetResponse);
1181         // resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
1182         // resourceDetails.getUniqueId());
1183         // assertEquals("Check response code after get resource", 200,
1184         // resourceGetResponse.getErrorCode().intValue());
1185         // resourceFromGet =
1186         // ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1187         // assertNotNull(resourceFromGet);
1188         // resourceDetails =
1189         // ResponseParser.parseToObject(importResponse.getResponse(),
1190         // ResourceReqDetails.class);
1191         // resourceDetails.setVersion(resourceFromGet.getVersion());
1192         //
1193         // // add artifact
1194         // artifactDefinition.setArtifactName(artifactName1);
1195         // ArtifactRestUtils.addInformationalArtifactToResource(resourceDetails,
1196         // sdncModifierDetails, resourceVersion , artifactDefinition);
1197         //
1198         // // add artifact
1199         // artifactDefinition.setArtifactName(artifactName2);
1200         // resourceUtils.add_artifact(resourceDetails, sdncModifierDetails,
1201         // resourceVersion , artifactDefinition);
1202         //
1203         // // add interface
1204         // artifactDefinition.setArtifactName(interfaceArtifactName);
1205         // ResourceRestUtils.add_interface(resourceDetails, sdncModifierDetails,
1206         // resourceVersion , artifactDefinition);
1207         //
1208         // //construct fields for validation
1209         // resourceVersion="1.0";
1210         //
1211         // ResourceRespJavaObject resourceRespJavaObject =
1212         // Convertor.constructFieldsForRespValidation(resourceDetails,
1213         // resourceVersion);
1214         // ArrayList<String> artifacts = new ArrayList<String>();
1215         //
1216         // artifacts.add(resourceId+":"+artifactName1);
1217         // artifacts.add(resourceId+":"+artifactName2);
1218         // resourceRespJavaObject.setArtifacts(artifacts);
1219         // ArrayList<String> interfaces = new ArrayList<String>();
1220         //
1221         // interfaces.add(interfaze);
1222         // resourceRespJavaObject.setInterfaces(interfaces);
1223         //
1224         // // checkIn resource
1225         // resourceVersion = resourceDetails.getVersion();
1226         // String checkinComment = "good checkin";
1227         // String checkinComentJson = "{\"userRemarks\": \""+checkinComment+"\"}";
1228         // RestResponse checkInResponse =
1229         // LifecycleRestUtils.changeResourceState(resourceDetails,
1230         // sdncModifierDetails, resourceVersion, LifeCycleStatesEnum.CHECKIN,
1231         // checkinComentJson);
1232         // assertNotNull("check response object is not null after import resource",
1233         // checkInResponse);
1234         // assertEquals("Check response code after checkout resource", 200,
1235         // checkInResponse.getErrorCode().intValue());
1236         //
1237         // // req4cert resource
1238         // RestResponse request4cert =
1239         // LifecycleRestUtils.changeResourceState(resourceDetails,
1240         // sdncModifierDetails, resourceVersion,
1241         // LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1242         // assertNotNull("check response object is not null after resource request
1243         // for certification", request4cert);
1244         // assertEquals("Check response code after checkout resource", 200,
1245         // request4cert.getErrorCode().intValue());
1246         // resourceFromGet =
1247         // ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
1248         // assertNotNull(resourceFromGet);
1249         // resourceDetails =
1250         // ResponseParser.parseToObject(request4cert.getResponse(),
1251         // ResourceReqDetails.class);
1252         // resourceDetails.setVersion(resourceFromGet.getVersion());
1253         //
1254         // // startCert
1255         // RestResponse startCert =
1256         // LifecycleRestUtils.changeResourceState(resourceDetails,
1257         // sdncModifierDetails, resourceVersion,
1258         // LifeCycleStatesEnum.STARTCERTIFICATION);
1259         // assertNotNull("check response object is not null after resource request
1260         // start certification", startCert);
1261         // assertEquals("Check response code after checkout resource", 200,
1262         // startCert.getErrorCode().intValue());
1263         // resourceFromGet =
1264         // ResponseParser.convertResourceResponseToJavaObject(startCert.getResponse());
1265         // assertNotNull(resourceFromGet);
1266         // resourceDetails = ResponseParser.parseToObject(startCert.getResponse(),
1267         // ResourceReqDetails.class);
1268         // resourceDetails.setVersion(resourceFromGet.getVersion());
1269         //
1270         // // certify
1271         // RestResponse certify =
1272         // LifecycleRestUtils.changeResourceState(resourceDetails,
1273         // sdncModifierDetails, resourceVersion, LifeCycleStatesEnum.CERTIFY);
1274         // assertNotNull("check response object is not null after resource request
1275         // certify", certify);
1276         // assertEquals("Check response code after certify resource", 200,
1277         // certify.getErrorCode().intValue());
1278         // resourceFromGet =
1279         // ResponseParser.convertResourceResponseToJavaObject(certify.getResponse());
1280         // assertNotNull(resourceFromGet);
1281         // resourceDetails = ResponseParser.parseToObject(certify.getResponse(),
1282         // ResourceReqDetails.class);
1283         // resourceDetails.setVersion(resourceFromGet.getVersion());
1284         //
1285         // // clean audit
1286         // DbUtils.cleanAllAudits();
1287         //
1288         // // change resource details
1289         //
1290         // // import new resource while resource already exist in other state
1291         // importResponse =
1292         // ImportRestUtils.importNewResourceByName("importResource4testUpdateWithoutReqCap",
1293         // UserRoleEnum.ADMIN);
1294         // assertNotNull("check response object is not null after import resource",
1295         // importResponse);
1296         // assertNotNull("check error code exists in response after import
1297         // resource", importResponse.getErrorCode());
1298         // assertEquals("Check response code after import resource", 200,
1299         // importResponse.getErrorCode().intValue());
1300         // resourceDetails =
1301         // ResponseParser.parseToObject(importResponse.getResponse(),
1302         // ResourceReqDetails.class);
1303         // resourceVersion = resourceDetails.getVersion();
1304         // resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
1305         // resourceDetails.getUniqueId());
1306         // assertEquals("Check response code after get resource", 200,
1307         // resourceGetResponse.getErrorCode().intValue());
1308         // resourceFromGet =
1309         // ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1310         // assertNotNull(resourceFromGet);
1311         //
1312         // // validate response
1313         // Resource resourceFromImport =
1314         // ResponseParser.convertResourceResponseToJavaObject(importResponse.getResponse());
1315         // assertNotNull(resourceFromImport);
1316         //
1317         // resourceDetails =
1318         // ResponseParser.parseToObject(importResponse.getResponse(),
1319         // ResourceReqDetails.class);
1320         // resourceRespJavaObject =
1321         // Convertor.constructFieldsForRespValidation(resourceDetails);
1322         // resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1323         //
1324         // // validate get response
1325         // resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
1326         // resourceRespJavaObject.getUniqueId());
1327         // resourceFromGet =
1328         // ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1329         // assertNotNull(resourceFromGet);
1330         //
1331         // // validate
1332         // ResourceValidationUtils.validateModelObjects(resourceFromImport,
1333         // resourceFromGet);
1334         //
1335         // // validate audit
1336         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1337         // Convertor.constructFieldsForAuditValidation(resourceDetails,
1338         // resourceVersion);
1339         // auditAction="ResourceImport";
1340         // expectedResourceAuditJavaObject.setAction(auditAction);
1341         // expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1342         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1343         // expectedResourceAuditJavaObject.setPrevVersion(resourceVersion);
1344         // expectedResourceAuditJavaObject.setStatus("200");
1345         // expectedResourceAuditJavaObject.setDesc("OK");
1346         // expectedResourceAuditJavaObject.setToscaNodeType(resourceFromGet.getToscaResourceName());
1347         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1348         // auditAction, null, false);
1349         // }
1350
1351         @Test
1352         public void importNewResource_uuidTest() throws Exception {
1353                 RestResponse importResponse = importNewResource(UserRoleEnum.ADMIN);
1354
1355                 assertNotNull("check response object is not null after import resource", importResponse);
1356                 assertNotNull("check error code exists in response after import resource", importResponse.getErrorCode());
1357                 assertEquals("Check response code after import resource", 201, importResponse.getErrorCode().intValue());
1358                 String oldUuid = ResponseParser.getValueFromJsonResponse(importResponse.getResponse(), "uuid");
1359
1360                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
1361                 resourceVersion = resourceDetails.getVersion();
1362                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
1363                                 resourceDetails.getUniqueId());
1364                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
1365                 Resource resourceFromGet = ResponseParser
1366                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1367                 assertNotNull(resourceFromGet);
1368                 // add mandatory artifacts
1369                 // resourceUtils.addResourceMandatoryArtifacts(sdncModifierDetails,
1370                 // resourceGetResponse);
1371                 resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails, resourceDetails.getUniqueId());
1372                 assertEquals("Check response code after get resource", 200, resourceGetResponse.getErrorCode().intValue());
1373                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1374                 assertNotNull(resourceFromGet);
1375                 resourceDetails = ResponseParser.parseToObject(importResponse.getResponse(), ResourceReqDetails.class);
1376                 resourceDetails.setVersion(resourceFromGet.getVersion());
1377
1378                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1379                                 "0.1", LifeCycleStatesEnum.CHECKIN);
1380                 assertNotNull("check response object is not null after import resource", checkInResponse);
1381                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
1382
1383                 String newUuid = ResponseParser.getValueFromJsonResponse(checkInResponse.getResponse(), "uuid");
1384                 assertTrue(ResourceValidationUtils.validateUuidAfterChangingStatus(oldUuid, newUuid));
1385
1386                 // req4cert resource
1387                 RestResponse request4cert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1388                                 resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1389                 assertNotNull("check response object is not null after resource request for certification", request4cert);
1390                 assertEquals("Check response code after checkout resource", 200, request4cert.getErrorCode().intValue());
1391                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(request4cert.getResponse());
1392                 assertNotNull(resourceFromGet);
1393                 resourceDetails = ResponseParser.parseToObject(request4cert.getResponse(), ResourceReqDetails.class);
1394                 resourceDetails.setVersion(resourceFromGet.getVersion());
1395
1396                 String newUuid2 = ResponseParser.getValueFromJsonResponse(request4cert.getResponse(), "uuid");
1397                 assertTrue(ResourceValidationUtils.validateUuidAfterChangingStatus(oldUuid, newUuid2));
1398
1399                 // startCert
1400                 RestResponse startCert = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1401                                 resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION);
1402                 assertNotNull("check response object is not null after resource request start certification", startCert);
1403                 assertEquals("Check response code after checkout resource", 200, startCert.getErrorCode().intValue());
1404                 resourceFromGet = ResponseParser.convertResourceResponseToJavaObject(startCert.getResponse());
1405                 assertNotNull(resourceFromGet);
1406                 resourceDetails = ResponseParser.parseToObject(startCert.getResponse(), ResourceReqDetails.class);
1407                 resourceDetails.setVersion(resourceFromGet.getVersion());
1408
1409                 String newUuid3 = ResponseParser.getValueFromJsonResponse(startCert.getResponse(), "uuid");
1410                 assertTrue(ResourceValidationUtils.validateUuidAfterChangingStatus(oldUuid, newUuid3));
1411
1412                 RestResponse certify = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, "0.1",
1413                                 LifeCycleStatesEnum.CERTIFY);
1414                 assertNotNull("check response object is not null after import resource", certify);
1415                 assertEquals("Check response code after checkout resource", 200, certify.getErrorCode().intValue());
1416
1417                 String newUuid4 = ResponseParser.getValueFromJsonResponse(certify.getResponse(), "uuid");
1418                 assertTrue(ResourceValidationUtils.validateUuidAfterChangingStatus(oldUuid, newUuid4));
1419
1420                 RestResponse checkoutResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails,
1421                                 "1.0", LifeCycleStatesEnum.CHECKOUT);
1422                 assertNotNull("check response object is not null after import resource", checkInResponse);
1423                 assertEquals("Check response code after checkout resource", 200, checkInResponse.getErrorCode().intValue());
1424
1425                 String newUuid5 = ResponseParser.getValueFromJsonResponse(checkoutResponse.getResponse(), "uuid");
1426                 assertFalse(ResourceValidationUtils.validateUuidAfterChangingStatus(oldUuid, newUuid5));
1427         }
1428
1429         @Test
1430         public void importNewResource_propertiesMapInternalUrlCredential() throws Exception {
1431                 String folderName = "validateProporties_typeMap_valueUrlCredential";
1432                 RestResponse importResponse = ImportRestUtils.importNewResourceByName(folderName, UserRoleEnum.DESIGNER);
1433
1434                 Resource resource = ResponseParser.parseToObjectUsingMapper(importResponse.getResponse(), Resource.class);
1435
1436                 List<PropertyDefinition> properties = resource.getProperties();
1437                 assertEquals("check properties size", 3, properties.size());
1438
1439                 PropertyDefinition propertyDefinition = properties.stream().filter(p -> p.getName().equals("validation_test"))
1440                                 .findFirst().get();
1441                 String defaultValue = propertyDefinition.getDefaultValue();
1442
1443                 Map mapValue = gson.fromJson(defaultValue, Map.class);
1444                 assertEquals("check Map value size", 2, mapValue.size());
1445                 checkMapValues(mapValue, "key", 1, null);
1446                 checkMapValues(mapValue, "key", 2, null);
1447
1448                 System.err.println("import Resource " + "<" + folderName + ">" + "response: " + importResponse.getErrorCode());
1449
1450         }
1451
1452         @Test
1453         public void importNewResource_propertiesListInternalUrlCredential() throws Exception {
1454                 String folderName = "validateProporties_typeList_valueUrlCredential";
1455                 RestResponse importResponse = ImportRestUtils.importNewResourceByName(folderName, UserRoleEnum.DESIGNER);
1456
1457                 Resource resource = ResponseParser.parseToObjectUsingMapper(importResponse.getResponse(), Resource.class);
1458
1459                 List<PropertyDefinition> properties = resource.getProperties();
1460                 assertEquals("check properties size", 3, properties.size());
1461
1462                 PropertyDefinition propertyDefinition = properties.stream().filter(p -> p.getName().equals("validation_test"))
1463                                 .findFirst().get();
1464                 String defaultValue = propertyDefinition.getDefaultValue();
1465
1466                 List listValue = gson.fromJson(defaultValue, List.class);
1467                 assertEquals("check List value size", 2, listValue.size());
1468                 checkListValues(listValue.get(0), 1, SPECIAL_CHARACTERS);
1469                 checkListValues(listValue.get(1), 2, SPECIAL_CHARACTERS);
1470
1471                 // Verify attributes
1472                 List<PropertyDefinition> attributes = resource.getAttributes();
1473
1474                 assertEquals("check properties size", 2, attributes.size());
1475
1476                 // Verify attribute from type map
1477                 PropertyDefinition attributeMapDefinition = attributes.stream()
1478                                 .filter(p -> p.getName().equals("validation_test_map")).findFirst().get();
1479                 String defaultMapValue = attributeMapDefinition.getDefaultValue();
1480                 Map attributeMapValue = gson.fromJson(defaultMapValue, Map.class);
1481                 assertEquals("check Map value size", 2, attributeMapValue.size());
1482                 checkMapValues(attributeMapValue, "key", 1, SPECIAL_CHARACTERS);
1483                 checkMapValues(attributeMapValue, "key", 2, SPECIAL_CHARACTERS);
1484
1485                 // Verify attribute from type list
1486                 PropertyDefinition attributeListDefinition = attributes.stream()
1487                                 .filter(p -> p.getName().equals("validation_test_list")).findFirst().get();
1488                 String defaultListValue = attributeListDefinition.getDefaultValue();
1489
1490                 List attributeListValue = gson.fromJson(defaultListValue, List.class);
1491                 assertEquals("check List value size", 2, attributeListValue.size());
1492                 checkListValues(attributeListValue.get(0), 1, SPECIAL_CHARACTERS);
1493                 checkListValues(attributeListValue.get(1), 2, SPECIAL_CHARACTERS);
1494
1495                 System.err.println("import Resource " + "<" + folderName + ">" + "response: " + importResponse.getErrorCode());
1496
1497         }
1498
1499         private void checkListValues(Object object, int index, String suffix) {
1500
1501                 Map map = (Map) object;
1502                 assertEquals("check Map protocol value", "protocol" + index + (suffix == null ? "" : suffix),
1503                                 map.get("protocol"));
1504                 assertEquals("check Map token value", "token" + index, map.get("token"));
1505         }
1506
1507         // @Test
1508         public void importNewResource_validateProporties_typeTestDataType() throws Exception {
1509                 String folderName = "validateProporties_typeTestDataType";
1510                 RestResponse importResponse = ImportRestUtils.importNewResourceByName(folderName, UserRoleEnum.DESIGNER);
1511
1512                 Resource resource = ResponseParser.parseToObjectUsingMapper(importResponse.getResponse(), Resource.class);
1513
1514         }
1515
1516         private void checkMapValues(Map mapValue, String key, int index, String suffix) {
1517
1518                 Map map1 = (Map) mapValue.get(key + index);
1519                 assertEquals("check Map protocol value", "protocol" + index + (suffix == null ? "" : suffix),
1520                                 map1.get("protocol"));
1521                 assertEquals("check Map token value", "token" + index, map1.get("token"));
1522
1523         }
1524 }