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