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