test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/resource/CreateResourceApiTest.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.resource;
  22
  23 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  24 import static org.testng.AssertJUnit.assertEquals;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33
  34 import javax.validation.constraints.AssertTrue;
  35
  36 import org.apache.log4j.lf5.util.ResourceUtils;
  37 import org.junit.Rule;
  38 import org.junit.rules.TestName;
  39 import org.openecomp.sdc.be.dao.api.ActionStatus;
  40 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  41 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  42 import org.openecomp.sdc.be.model.Component;
  43 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  44 import org.openecomp.sdc.be.model.Resource;
  45 import org.openecomp.sdc.be.model.Service;
  46 import org.openecomp.sdc.be.model.User;
  47 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  48 import org.openecomp.sdc.ci.tests.api.Urls;
  49 import org.openecomp.sdc.ci.tests.config.Config;
  50 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  51 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  52 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  53 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
  54 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  55 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  56 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  57 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  58 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  59 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  60 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  61 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  62 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  63 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  64 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  65 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  66 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  67 import org.openecomp.sdc.ci.tests.utils.Utils;
  68 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  69 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
  70 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  71 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  72 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  73 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  74 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  75 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  76 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  77 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  78 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  79 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  80 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
  81 import org.openecomp.sdc.ci.tests.utils.validation.ServiceValidationUtils;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84 import org.testng.annotations.Test;
  85
  86 import com.google.gson.Gson;
  87
  88 /**
  89  * @author yshlosberg
  90  *
  91  */
  92 public class CreateResourceApiTest extends ComponentBaseTest {
  93
  94         private static Logger log = LoggerFactory.getLogger(CreateResourceApiTest.class.getName());
  95
  96         String contentTypeHeaderData = "application/json";
  97         String acceptHeaderDate = "application/json";
  98         String resourceVersion = "0.1";
  99
 100         @Rule
 101         public static TestName name = new TestName();
 102
 103         public CreateResourceApiTest() {
 104                 super(name, CreateResourceApiTest.class.getName());
 105         }
 106
 107         @Test
 108         public void createResourceTest() throws Exception {
 109
 110                 // init ADMIN user
 111                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 112
 113                 // ResourceReqDetails resourceDetails = new
 114                 // ResourceReqDetails(resourceName, description, resourceTags, category,
 115                 // derivedFrom, vendorName, vendorRelease, contactId, icon);
 116                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 117                 String resourceName = resourceDetails.getName();
 118                 resourceDetails.setTags(Arrays.asList(resourceName, resourceName, resourceName, resourceName, "tag2", "tag2"));
 119                 // create resource
 120                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 121
 122                 // validate response
 123                 assertNotNull("check response object is not null after create resource", createResponse);
 124                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 125                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 126
 127                 // validate response
 128                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 129                                 resourceVersion);
 130                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 131                 resourceRespJavaObject.setAbstractt("false");
 132                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 133
 134                 // validate get response
 135                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 136                                 resourceDetails.getUniqueId());
 137                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 138
 139                 // validate audit
 140                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 141                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 142                 String auditAction = "Create";
 143                 expectedResourceAuditJavaObject.setAction(auditAction);
 144                 expectedResourceAuditJavaObject.setPrevVersion("");
 145                 expectedResourceAuditJavaObject.setPrevState("");
 146                 expectedResourceAuditJavaObject.setStatus("201");
 147                 expectedResourceAuditJavaObject.setDesc("OK");
 148
 149                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 150         }
 151
 152         @Test
 153         public void createResourceNonDefaultResourceTypeTest() throws Exception {
 154
 155                 // init ADMIN user
 156                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 157
 158                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 159                 String resourceType = ResourceTypeEnum.CP.toString();
 160                 resourceDetails.setResourceType(resourceType);
 161                 // create resource
 162                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 163
 164                 // validate response
 165                 assertNotNull("check response object is not null after create resource", createResponse);
 166                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 167                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 168
 169                 // validate response
 170                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 171                                 resourceVersion);
 172                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 173                 resourceRespJavaObject.setAbstractt("false");
 174                 resourceRespJavaObject.setResourceType(resourceType);
 175                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 176
 177                 // validate get response
 178                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 179                                 resourceDetails.getUniqueId());
 180                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 181
 182                 // validate audit
 183                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 184                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 185                 String auditAction = "Create";
 186                 expectedResourceAuditJavaObject.setAction(auditAction);
 187                 expectedResourceAuditJavaObject.setPrevVersion("");
 188                 expectedResourceAuditJavaObject.setPrevState("");
 189                 expectedResourceAuditJavaObject.setStatus("201");
 190                 expectedResourceAuditJavaObject.setDesc("OK");
 191
 192                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 193         }
 194
 195         @Test
 196         public void createResourceTest_costAndLicenseType() throws Exception {
 197
 198                 // init ADMIN user
 199
 200                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 201
 202                 // set resource details
 203                 String resourceName = "CISCO4572";
 204                 String description = "description";
 205                 // Duplicate tags are allowed and should be de-duplicated by the server
 206                 // side
 207                 ArrayList<String> resourceTags = new ArrayList<String>();
 208                 resourceTags.add(resourceName);
 209                 resourceTags.add(resourceName);
 210                 resourceTags.add(resourceName);
 211                 resourceTags.add("tag2");
 212                 resourceTags.add("tag2");
 213                 String category = ServiceCategoriesEnum.VOIP.getValue();
 214                 ArrayList<String> derivedFrom = new ArrayList<String>();
 215                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 216                 String vendorName = "Oracle";
 217                 String vendorRelease = "1.5";
 218                 String contactId = "jh0003";
 219                 String icon = "myICON";
 220
 221                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 222                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 223                 // Adding cost and licenseType
 224                 resourceDetails.setCost("12355.345");
 225                 resourceDetails.setLicenseType("User");
 226
 227                 // create resource
 228                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 229
 230                 // validate response
 231                 assertNotNull("check response object is not null after create resource", createResponse);
 232                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 233                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 234
 235                 // validate response
 236                 String resourceVersion = "0.1";
 237                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 238                                 resourceVersion);
 239                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 240                 resourceRespJavaObject.setAbstractt("false");
 241                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 242
 243                 // validate get response
 244
 245                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 246                                 resourceDetails.getUniqueId());
 247                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 248
 249         }
 250
 251         // ////Benny
 252         @Test
 253         public void createResourceTest_CostIsMissing() throws Exception {
 254
 255                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 256                 // set resource details
 257                 String resourceName = "CISCO4572";
 258                 String description = "description";
 259                 // Duplicate tags are allowed and should be de-duplicated by the server
 260                 // side
 261                 ArrayList<String> resourceTags = new ArrayList<String>();
 262                 resourceTags.add(resourceName);
 263                 resourceTags.add(resourceName);
 264                 resourceTags.add(resourceName);
 265                 resourceTags.add("tag2");
 266                 resourceTags.add("tag2");
 267                 String category = ServiceCategoriesEnum.VOIP.getValue();
 268                 ArrayList<String> derivedFrom = new ArrayList<String>();
 269                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 270                 String vendorName = "Oracle";
 271                 String vendorRelease = "1.5";
 272                 String contactId = "jh0003";
 273                 String icon = "myICON";
 274
 275                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 276                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 277                 // Adding cost and licenseType
 278                 // resourceDetails.setCost("12355.345");
 279                 resourceDetails.setLicenseType("User");
 280
 281                 // create resource
 282                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 283                 assertNotNull("check response object is not null after create resource", createResponse);
 284                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 285                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 286
 287                 // validate response
 288                 String resourceVersion = "0.1";
 289                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 290                                 resourceVersion);
 291                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 292                 resourceRespJavaObject.setAbstractt("false");
 293                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 294
 295                 // validate get response
 296                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 297                                 resourceDetails.getUniqueId());
 298                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 299         }
 300
 301         @Test
 302         public void createResourceTest_LicenseTypeMissing() throws Exception {
 303
 304                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 305                 // set resource details
 306                 String resourceName = "CISCO4572";
 307                 String description = "description";
 308                 // Duplicate tags are allowed and should be de-duplicated by the server
 309                 // side
 310                 ArrayList<String> resourceTags = new ArrayList<String>();
 311                 resourceTags.add(resourceName);
 312                 resourceTags.add(resourceName);
 313                 resourceTags.add(resourceName);
 314                 resourceTags.add("tag2");
 315                 resourceTags.add("tag2");
 316                 String category = ServiceCategoriesEnum.VOIP.getValue();
 317                 ArrayList<String> derivedFrom = new ArrayList<String>();
 318                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 319                 String vendorName = "Oracle";
 320                 String vendorRelease = "1.5";
 321                 String contactId = "jh0003";
 322                 String icon = "myICON";
 323
 324                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 325                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 326                 // Adding cost and licenseType
 327                 resourceDetails.setCost("12355.345");
 328                 // resourceDetails.setLicenseType("User");
 329
 330                 // create resource
 331                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 332                 assertNotNull("check response object is not null after create resource", createResponse);
 333                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 334                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 335
 336                 // validate response
 337                 String resourceVersion = "0.1";
 338                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 339                                 resourceVersion);
 340                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 341                 resourceRespJavaObject.setAbstractt("false");
 342                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 343
 344                 // validate get response
 345                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 346                                 resourceDetails.getUniqueId());
 347                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 348         }
 349
 350         @Test
 351         public void createResourceTest_LicenseType_Installation() throws Exception {
 352
 353                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 354                 // set resource details
 355                 String resourceName = "CISCO4572";
 356                 String description = "description";
 357                 // Duplicate tags are allowed and should be de-duplicated by the server
 358                 // side
 359                 ArrayList<String> resourceTags = new ArrayList<String>();
 360                 resourceTags.add(resourceName);
 361                 resourceTags.add(resourceName);
 362                 resourceTags.add(resourceName);
 363                 resourceTags.add("tag2");
 364                 resourceTags.add("tag2");
 365                 String category = ServiceCategoriesEnum.VOIP.getValue();
 366                 ArrayList<String> derivedFrom = new ArrayList<String>();
 367                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 368                 String vendorName = "Oracle";
 369                 String vendorRelease = "1.5";
 370                 String contactId = "jh0003";
 371                 String icon = "myICON";
 372
 373                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 374                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 375                 // Adding cost and licenseType
 376                 resourceDetails.setCost("99999.999");
 377                 resourceDetails.setLicenseType("Installation");
 378
 379                 // create resource
 380                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 381                 assertNotNull("check response object is not null after create resource", createResponse);
 382                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 383                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 384
 385                 // validate response
 386                 String resourceVersion = "0.1";
 387                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 388                                 resourceVersion);
 389                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 390                 resourceRespJavaObject.setAbstractt("false");
 391                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 392
 393                 // validate get response
 394                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 395                                 resourceDetails.getUniqueId());
 396                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 397         }
 398
 399         @Test
 400         public void createResourceTest_LicenseType_CPU() throws Exception {
 401
 402                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 403                 // set resource details
 404                 String resourceName = "CISCO4572";
 405                 String description = "description";
 406                 // Duplicate tags are allowed and should be de-duplicated by the server
 407                 // side
 408                 ArrayList<String> resourceTags = new ArrayList<String>();
 409                 resourceTags.add(resourceName);
 410                 resourceTags.add(resourceName);
 411                 resourceTags.add(resourceName);
 412                 resourceTags.add("tag2");
 413                 resourceTags.add("tag2");
 414                 String category = ServiceCategoriesEnum.VOIP.getValue();
 415                 ArrayList<String> derivedFrom = new ArrayList<String>();
 416                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 417                 String vendorName = "Oracle";
 418                 String vendorRelease = "1.5";
 419                 String contactId = "jh0003";
 420                 String icon = "myICON";
 421
 422                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 423                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 424                 // Adding cost and licenseType
 425                 resourceDetails.setCost("0.0");
 426                 resourceDetails.setLicenseType("CPU");
 427
 428                 // create resource
 429                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 430                 assertNotNull("check response object is not null after create resource", createResponse);
 431                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 432                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
 433
 434                 // validate response
 435                 String resourceVersion = "0.1";
 436                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 437                                 resourceVersion);
 438                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 439                 resourceRespJavaObject.setAbstractt("false");
 440                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
 441
 442                 // validate get response
 443                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncModifierDetails,
 444                                 resourceDetails.getUniqueId());
 445                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 446         }
 447
 448         @Test
 449         public void createResourceTest_LicenseType_Uppercase() throws Exception {
 450
 451                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 452                 // set resource details
 453                 String resourceName = "CISCO4572";
 454                 String description = "description";
 455                 // Duplicate tags are allowed and should be de-duplicated by the server
 456                 // side
 457                 ArrayList<String> resourceTags = new ArrayList<String>();
 458                 resourceTags.add(resourceName);
 459                 resourceTags.add(resourceName);
 460                 resourceTags.add(resourceName);
 461                 resourceTags.add("tag2");
 462                 resourceTags.add("tag2");
 463                 String category = ServiceCategoriesEnum.VOIP.getValue();
 464                 ArrayList<String> derivedFrom = new ArrayList<String>();
 465                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 466                 String vendorName = "Oracle";
 467                 String vendorRelease = "1.5";
 468                 String contactId = "jh0003";
 469                 String icon = "myICON";
 470
 471                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 472                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 473                 // Adding cost and licenseType
 474                 resourceDetails.setCost("0.0");
 475                 resourceDetails.setLicenseType("INSTALLATION");
 476
 477                 // create resource
 478                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 479                 assertNotNull("check response object is not null after create resource", createResponse);
 480                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 481                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 482                 assertEquals("Check response code after create resource", "Bad Request", createResponse.getResponseMessage());
 483         }
 484
 485         @Test
 486         public void createResourceTest_LicenseType_Invalid() throws Exception {
 487
 488                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 489                 // set resource details
 490                 String resourceName = "CISCO4572";
 491                 String description = "description";
 492                 // Duplicate tags are allowed and should be de-duplicated by the server
 493                 // side
 494                 ArrayList<String> resourceTags = new ArrayList<String>();
 495                 resourceTags.add(resourceName);
 496                 resourceTags.add(resourceName);
 497                 resourceTags.add(resourceName);
 498                 resourceTags.add("tag2");
 499                 resourceTags.add("tag2");
 500                 String category = ServiceCategoriesEnum.VOIP.getValue();
 501                 ArrayList<String> derivedFrom = new ArrayList<String>();
 502                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 503                 String vendorName = "Oracle";
 504                 String vendorRelease = "1.5";
 505                 String contactId = "jh0003";
 506                 String icon = "myICON";
 507
 508                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 509                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 510                 // Adding cost and licenseType
 511                 resourceDetails.setCost("0.0");
 512                 resourceDetails.setLicenseType("CPUUU");
 513
 514                 // create resource
 515                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 516                 assertNotNull("check response object is not null after create resource", createResponse);
 517                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 518                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 519                 assertEquals("Check response code after create resource", "Bad Request", createResponse.getResponseMessage());
 520         }
 521
 522         @Test
 523         public void createResourceTest_CostValidation_noNumeric() throws Exception {
 524
 525                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 526                 // set resource details
 527                 String resourceName = "CISCO4572";
 528                 String description = "description";
 529                 // Duplicate tags are allowed and should be de-duplicated by the server
 530                 // side
 531                 ArrayList<String> resourceTags = new ArrayList<String>();
 532                 resourceTags.add(resourceName);
 533                 resourceTags.add(resourceName);
 534                 resourceTags.add(resourceName);
 535                 resourceTags.add("tag2");
 536                 resourceTags.add("tag2");
 537                 String category = ServiceCategoriesEnum.VOIP.getValue();
 538                 ArrayList<String> derivedFrom = new ArrayList<String>();
 539                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 540                 String vendorName = "Oracle";
 541                 String vendorRelease = "1.5";
 542                 String contactId = "jh0003";
 543                 String icon = "myICON";
 544
 545                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 546                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 547                 // Adding cost and licenseType
 548                 resourceDetails.setCost("12355.345");
 549                 resourceDetails.setLicenseType("User");
 550                 resourceDetails.setCost("12355.34b");
 551                 // create resource
 552                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 553                 assertNotNull("check response object is not null after create resource", createResponse);
 554                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 555                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 556                 assertEquals("Check response code after create resource", "Bad Request",
 557                                 createResponse.getResponseMessage().toString());
 558
 559         }
 560
 561         @Test
 562         public void createResourceTest_CostValidation_valueLength() throws Exception {
 563
 564                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 565                 // set resource details
 566                 String resourceName = "CISCO4572";
 567                 String description = "description";
 568                 // Duplicate tags are allowed and should be de-duplicated by the server
 569                 // side
 570                 ArrayList<String> resourceTags = new ArrayList<String>();
 571                 resourceTags.add(resourceName);
 572                 resourceTags.add(resourceName);
 573                 resourceTags.add(resourceName);
 574                 resourceTags.add("tag2");
 575                 resourceTags.add("tag2");
 576                 String category = ServiceCategoriesEnum.VOIP.getValue();
 577                 ArrayList<String> derivedFrom = new ArrayList<String>();
 578                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 579                 String vendorName = "Oracle";
 580                 String vendorRelease = "1.5";
 581                 String contactId = "jh0003";
 582                 String icon = "myICON";
 583                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 584                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 585                 // Adding cost and licenseType
 586                 resourceDetails.setCost("12355.345");
 587                 resourceDetails.setLicenseType("User");
 588
 589                 // Adding invalid cost
 590                 resourceDetails.setCost("12355.3434");
 591                 // create resource
 592                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 593                 assertNotNull("check response object is not null after create resource", createResponse);
 594                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 595                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 596                 assertEquals("Check response code after create resource", "Bad Request",
 597                                 createResponse.getResponseMessage().toString());
 598         }
 599
 600         @Test
 601         public void createResourceTest_CostValidation_PriceLimitations() throws Exception {
 602
 603                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 604                 // set resource details
 605                 String resourceName = "CISCO4572";
 606                 String description = "description";
 607                 // Duplicate tags are allowed and should be de-duplicated by the server
 608                 // side
 609                 ArrayList<String> resourceTags = new ArrayList<String>();
 610                 resourceTags.add(resourceName);
 611                 resourceTags.add(resourceName);
 612                 resourceTags.add(resourceName);
 613                 resourceTags.add("tag2");
 614                 resourceTags.add("tag2");
 615                 String category = ServiceCategoriesEnum.VOIP.getValue();
 616                 ArrayList<String> derivedFrom = new ArrayList<String>();
 617                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 618                 String vendorName = "Oracle";
 619                 String vendorRelease = "1.5";
 620                 String contactId = "jh0003";
 621                 String icon = "myICON";
 622                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 623                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 624                 // Adding cost and licenseType
 625                 resourceDetails.setCost("12355.345");
 626                 resourceDetails.setLicenseType("User");
 627
 628                 // Adding invalid cost
 629                 RestResponse createResponse;
 630                 // create resource
 631
 632                 resourceDetails.setCost("000000.000");
 633                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 634                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 635                 assertNotNull("check response object is not null after create resource", createResponse);
 636                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 637                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 638                 assertEquals("Check response code after create resource", "Bad Request",
 639                                 createResponse.getResponseMessage().toString());
 640
 641                 /*
 642                  * resourceDetails.setCost("0550.457"); createResponse =
 643                  * resourceUtils.createResource(resourceDetails, sdncModifierDetails);
 644                  * assertNotNull("check response object is not null after create resource"
 645                  * , createResponse);
 646                  * assertNotNull("check error code exists in response after create resource"
 647                  * , createResponse.getErrorCode());
 648                  * assertEquals("Check response code after create resource", 400,
 649                  * createResponse.getErrorCode().intValue());
 650                  * assertEquals("Check response code after create resource",
 651                  * "Bad Request", createResponse.getResponseMessage().toString());
 652                  */
 653
 654                 resourceDetails.setCost("1");
 655                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 656                 assertNotNull("check response object is not null after create resource", createResponse);
 657                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 658                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 659                 assertEquals("Check response code after create resource", "Bad Request",
 660                                 createResponse.getResponseMessage().toString());
 661
 662                 resourceDetails.setCost("123555.340");
 663                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 664                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 665                 assertNotNull("check response object is not null after create resource", createResponse);
 666                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 667                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 668                 assertEquals("Check response code after create resource", "Bad Request",
 669                                 createResponse.getResponseMessage().toString());
 670
 671                 resourceDetails.setCost("123.4570");
 672                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 673                 assertNotNull("check response object is not null after create resource", createResponse);
 674                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 675                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 676                 assertEquals("Check response code after create resource", "Bad Request",
 677                                 createResponse.getResponseMessage().toString());
 678
 679                 resourceDetails.setCost("123555.30");
 680                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 681                 assertNotNull("check response object is not null after create resource", createResponse);
 682                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 683                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 684                 assertEquals("Check response code after create resource", "Bad Request",
 685                                 createResponse.getResponseMessage().toString());
 686
 687                 resourceDetails.setCost("123.5550");
 688                 createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 689                 assertNotNull("check response object is not null after create resource", createResponse);
 690                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 691                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 692                 assertEquals("Check response code after create resource", "Bad Request",
 693                                 createResponse.getResponseMessage().toString());
 694
 695         }
 696
 697         @Test
 698         public void createResourceTest_CostIsNull() throws Exception {
 699
 700                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 701                 // set resource details
 702                 String resourceName = "CISCO4572";
 703                 String description = "description";
 704                 // Duplicate tags are allowed and should be de-duplicated by the server
 705                 // side
 706                 ArrayList<String> resourceTags = new ArrayList<String>();
 707                 resourceTags.add(resourceName);
 708                 resourceTags.add(resourceName);
 709                 resourceTags.add(resourceName);
 710                 resourceTags.add("tag2");
 711                 resourceTags.add("tag2");
 712                 String category = ServiceCategoriesEnum.VOIP.getValue();
 713                 ArrayList<String> derivedFrom = new ArrayList<String>();
 714                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 715                 String vendorName = "Oracle";
 716                 String vendorRelease = "1.5";
 717                 String contactId = "jh0003";
 718                 String icon = "myICON";
 719
 720                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 721                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 722                 // Adding cost and licenseType
 723                 resourceDetails.setCost("12355.345");
 724                 resourceDetails.setLicenseType("User");
 725                 resourceDetails.setCost("");
 726                 // create resource
 727                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 728                 assertNotNull("check response object is not null after create resource", createResponse);
 729                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 730                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 731                 assertEquals("Check response code after create resource", "Bad Request", createResponse.getResponseMessage());
 732
 733         }
 734
 735         @Test
 736         public void createResourceTest_LicenseIsNull() throws Exception {
 737
 738                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 739                 // set resource details
 740                 String resourceName = "CISCO4572";
 741                 String description = "description";
 742                 // Duplicate tags are allowed and should be de-duplicated by the server
 743                 // side
 744                 ArrayList<String> resourceTags = new ArrayList<String>();
 745                 resourceTags.add(resourceName);
 746                 resourceTags.add(resourceName);
 747                 resourceTags.add(resourceName);
 748                 resourceTags.add("tag2");
 749                 resourceTags.add("tag2");
 750                 String category = ServiceCategoriesEnum.VOIP.getValue();
 751                 ArrayList<String> derivedFrom = new ArrayList<String>();
 752                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 753                 String vendorName = "Oracle";
 754                 String vendorRelease = "1.5";
 755                 String contactId = "jh0003";
 756                 String icon = "myICON";
 757
 758                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 759                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 760                 // Adding cost and licenseType
 761                 resourceDetails.setCost("12355.345");
 762                 resourceDetails.setLicenseType("User");
 763                 resourceDetails.setLicenseType("");
 764                 // create resource
 765                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 766                 assertNotNull("check response object is not null after create resource", createResponse);
 767                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
 768                 assertEquals("Check response code after create resource", 400, createResponse.getErrorCode().intValue());
 769                 assertEquals("Check response code after create resource", "Bad Request", createResponse.getResponseMessage());
 770
 771         }
 772
 773         @Test
 774         public void createResourceTest_uri_methods() throws Exception {
 775
 776                 // init ADMIN user
 777                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 778
 779                 // set resource details
 780                 ResourceReqDetails resourceDetails = createRandomResource();
 781
 782                 Config config = Utils.getConfig();
 783
 784                 Map<String, String> headersMap = new HashMap<String, String>();
 785                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 786                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 787                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 788
 789                 Gson gson = new Gson();
 790                 String userBodyJson = gson.toJson(resourceDetails);
 791                 log.debug(userBodyJson);
 792                 HttpRequest http = new HttpRequest();
 793                 String url = String.format(Urls.CREATE_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort());
 794
 795                 RestResponse createResourceResponse2 = http.httpSendByMethod(url, "PUT", userBodyJson, headersMap);
 796
 797                 // validate response
 798                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.NOT_ALLOWED.name());
 799
 800                 assertNotNull("check response object is not null after create resource", createResourceResponse2);
 801                 assertNotNull("check error code exists in response after create resource",
 802                                 createResourceResponse2.getErrorCode());
 803                 assertEquals("Check response code after create resource", errorInfo.getCode(),
 804                                 createResourceResponse2.getErrorCode());
 805
 806                 List<String> variables = Arrays.asList();
 807                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_ALLOWED.name(), variables,
 808                                 createResourceResponse2.getResponse());
 809
 810         }
 811
 812         private ResourceReqDetails createRandomResource() {
 813                 String resourceName = "CISCO4";
 814                 String description = "description";
 815                 ArrayList<String> resourceTags = new ArrayList<String>();
 816                 resourceTags.add(resourceName);
 817                 String category = ServiceCategoriesEnum.VOIP.getValue();
 818                 ArrayList<String> derivedFrom = new ArrayList<String>();
 819                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
 820                 String vendorName = "Oracle";
 821                 String vendorRelease = "1.5";
 822                 String contactId = "jh0003";
 823                 String icon = "myICON";
 824
 825                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
 826                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 827                 return resourceDetails;
 828         }
 829
 830         @Test
 831         public void createResource_role_tester() throws Exception {
 832
 833                 // init TESTER user
 834                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 835
 836                 ResourceReqDetails resourceDetails2 = createRandomResource();
 837
 838                 // create resource
 839                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
 840
 841                 // validate response
 842                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 843
 844                 assertNotNull("check response object is not null after create resouce", restResponse2);
 845                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
 846                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
 847
 848                 List<String> variables = Arrays.asList();
 849                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), variables,
 850                                 restResponse2.getResponse());
 851
 852                 // validate audit
 853                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 854                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
 855                 String auditAction = "Create";
 856                 expectedResourceAuditJavaObject.setAction(auditAction);
 857                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.TESTER.getUserId());
 858                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.TESTER.getUserName());
 859                 expectedResourceAuditJavaObject.setPrevState("");
 860                 expectedResourceAuditJavaObject.setCurrState("");
 861                 expectedResourceAuditJavaObject.setPrevVersion("");
 862                 expectedResourceAuditJavaObject.setCurrVersion("");
 863                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 864
 865                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 866                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 867
 868                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 869
 870         }
 871
 872         // TODO DE171450(to check)
 873         @Test
 874         public void createResource_role_DESIGNER() throws Exception {
 875
 876                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 877                 ResourceReqDetails resourceDetails = createRandomResource();
 878                 RestResponse restResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 879                 // validate response
 880                 assertNotNull("check response object is not null after create resource", restResponse);
 881                 assertNotNull("check error code exists in response after create resource", restResponse.getErrorCode());
 882                 assertEquals(
 883                                 "Check response code after create resource, response message is: " + restResponse.getResponseMessage(),
 884                                 201, restResponse.getErrorCode().intValue());
 885
 886         }
 887
 888         @Test
 889         public void createResource_missing_header() throws Exception {
 890                 // init ADMIN user
 891
 892                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 893
 894                 ResourceReqDetails resourceDetails = createRandomResource();
 895
 896                 // set null in userId header
 897                 sdncModifierDetails.setUserId(null);
 898
 899                 // create resource
 900
 901                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 902
 903                 // validate response
 904
 905                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
 906
 907                 assertNotNull("check response object is not null after create resouce", restResponse2);
 908                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
 909                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
 910
 911                 List<String> variables = Arrays.asList();
 912                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), variables,
 913                                 restResponse2.getResponse());
 914
 915                 // //validate audit
 916                 //
 917                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 918                 // resourceUtils.constructFieldsForAuditValidation(resourceDetails,resourceVersion);
 919                 //
 920                 // String auditAction="Create";
 921                 // expectedResourceAuditJavaObject.setAction(auditAction);
 922                 // expectedResourceAuditJavaObject.setModifierUid("null null");
 923                 // expectedResourceAuditJavaObject.setModifierName("null null");
 924                 // expectedResourceAuditJavaObject.setPrevState("");
 925                 // expectedResourceAuditJavaObject.setCurrState("");
 926                 // expectedResourceAuditJavaObject.setPrevVersion("");
 927                 // expectedResourceAuditJavaObject.setCurrVersion("");
 928                 // expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 929                 //
 930                 // String auditDesc =
 931                 // AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 932                 // expectedResourceAuditJavaObject.setDesc(auditDesc);
 933                 //
 934                 // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 935                 // auditAction);
 936                 // TODO: yshlosberg enable back
 937
 938         }
 939
 940         @Test
 941         public void createResource_existing_resource() throws Exception {
 942                 // init ADMIN user
 943
 944                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 945
 946                 // ResourceReqDetails resourceDetails = createRandomResource();
 947                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 948
 949                 // create resource
 950                 RestResponse restResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 951
 952                 // validate response
 953                 assertNotNull("check response object is not null after create resource", restResponse);
 954                 assertNotNull("check error code exists in response after create resource", restResponse.getErrorCode());
 955                 assertEquals("Check response code after create resource", 201, restResponse.getErrorCode().intValue());
 956
 957                 // set resource details
 958                 ResourceReqDetails resourceDetails2 = ElementFactory.getDefaultResource();
 959                 resourceDetails2.setName(resourceDetails.getName());
 960
 961                 // clean ES DB
 962                 DbUtils.cleanAllAudits();
 963
 964                 // create resource
 965                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
 966
 967                 // validate response
 968
 969                 ErrorInfo errorInfo = ErrorValidationUtils
 970                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name());
 971
 972                 assertNotNull("check response object is not null after create resouce", restResponse2);
 973                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
 974                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
 975
 976                 List<String> variables = Arrays.asList("Resource", resourceDetails2.getName());
 977                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name(), variables,
 978                                 restResponse2.getResponse());
 979
 980                 // validate audit
 981
 982                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
 983                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
 984
 985                 String auditAction = "Create";
 986                 expectedResourceAuditJavaObject.setAction(auditAction);
 987                 expectedResourceAuditJavaObject.setCurrState("");
 988                 expectedResourceAuditJavaObject.setCurrVersion("");
 989                 expectedResourceAuditJavaObject.setPrevState("");
 990                 expectedResourceAuditJavaObject.setPrevVersion("");
 991                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 992
 993                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 994                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 995
 996                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 997
 998         }
 999
1000         @Test
1001         public void createResourceTest_without_category() throws Exception {
1002
1003                 // init ADMIN user
1004
1005                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1006                 ;
1007
1008                 // set resource details
1009                 String resourceName = "CISCO4";
1010                 String description = "description";
1011                 ArrayList<String> resourceTags = new ArrayList<String>();
1012                 resourceTags.add(resourceName);
1013                 String category = ServiceCategoriesEnum.VOIP.getValue();
1014                 ArrayList<String> derivedFrom = new ArrayList<String>();
1015                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1016                 String vendorName = "Oracle";
1017                 String vendorRelease = "1.5";
1018                 String contactId = "jh0003";
1019                 String icon = "myICON";
1020
1021                 // set resource details
1022                 category = null;
1023
1024                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
1025                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1026
1027                 // create resource
1028
1029                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1030
1031                 // validate response
1032
1033                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_CATEGORY.name());
1034
1035                 assertNotNull("check response object is not null after create resouce", restResponse2);
1036                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1037                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1038
1039                 List<String> variables = Arrays.asList("Resource");
1040                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_CATEGORY.name(), variables,
1041                                 restResponse2.getResponse());
1042
1043                 // validate audit
1044
1045                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1046                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
1047
1048                 String auditAction = "Create";
1049                 expectedResourceAuditJavaObject.setAction(auditAction);
1050                 expectedResourceAuditJavaObject.setCurrState("");
1051                 expectedResourceAuditJavaObject.setCurrVersion("");
1052                 expectedResourceAuditJavaObject.setPrevState("");
1053                 expectedResourceAuditJavaObject.setPrevVersion("");
1054                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1055
1056                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1057                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1058
1059                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1060
1061         }
1062
1063         @Test
1064         public void createResourceTest_empty_category() throws Exception {
1065
1066                 // init ADMIN user
1067
1068                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1069
1070                 // set resource details
1071                 String resourceName = "CISCO4";
1072                 String description = "description";
1073                 ArrayList<String> resourceTags = new ArrayList<String>();
1074                 resourceTags.add(resourceName);
1075                 String category = ServiceCategoriesEnum.VOIP.getValue();
1076                 ArrayList<String> derivedFrom = new ArrayList<String>();
1077                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1078                 String vendorName = "Oracle";
1079                 String vendorRelease = "1.5";
1080                 String contactId = "jh0003";
1081                 String icon = "myICON";
1082
1083                 // set resource details
1084                 category = "";
1085
1086                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1087                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1088
1089                 // create resource
1090
1091                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1092
1093                 // validate response
1094
1095                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_CATEGORY.name());
1096
1097                 assertNotNull("check response object is not null after create resouce", restResponse2);
1098                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1099                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1100
1101                 List<String> variables = Arrays.asList("Resource");
1102                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_CATEGORY.name(), variables,
1103                                 restResponse2.getResponse());
1104
1105                 // validate audit
1106
1107                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1108                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1109
1110                 String auditAction = "Create";
1111                 expectedResourceAuditJavaObject.setAction(auditAction);
1112                 expectedResourceAuditJavaObject.setCurrState("");
1113                 expectedResourceAuditJavaObject.setCurrVersion("");
1114                 expectedResourceAuditJavaObject.setPrevState("");
1115                 expectedResourceAuditJavaObject.setPrevVersion("");
1116                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1117
1118                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1119                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1120
1121                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1122
1123         }
1124
1125         @Test
1126         public void createResourceTest_without_tags() throws Exception {
1127
1128                 // init ADMIN user
1129
1130                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1131                 ;
1132
1133                 // set resource details
1134                 String resourceName = "CISCO4";
1135                 String description = "description";
1136                 ArrayList<String> resourceTags = new ArrayList<String>();
1137
1138                 String category = ServiceCategoriesEnum.VOIP.getValue();
1139                 ArrayList<String> derivedFrom = new ArrayList<String>();
1140                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1141                 String vendorName = "Oracle";
1142                 String vendorRelease = "1.5";
1143                 String contactId = "jh0003";
1144                 String icon = "myICON";
1145
1146                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1147                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1148
1149                 // create resource
1150                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1151
1152                 // validate response
1153
1154                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_TAGS.name());
1155
1156                 assertNotNull("check response object is not null after create resouce", restResponse2);
1157                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1158                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1159
1160                 List<String> variables = Arrays.asList();
1161                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_TAGS.name(), variables,
1162                                 restResponse2.getResponse());
1163
1164                 // validate audit
1165
1166                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1167                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1168
1169                 String auditAction = "Create";
1170                 expectedResourceAuditJavaObject.setAction(auditAction);
1171                 expectedResourceAuditJavaObject.setCurrState("");
1172                 expectedResourceAuditJavaObject.setCurrVersion("");
1173                 expectedResourceAuditJavaObject.setPrevState("");
1174                 expectedResourceAuditJavaObject.setPrevVersion("");
1175                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1176
1177                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1178                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1179
1180                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1181
1182         }
1183
1184         // TODO DE171450(to check)
1185         @Test
1186         public void createResourceTest_with_multiple_tags() throws Exception {
1187
1188                 // init ADMIN user
1189                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1190
1191                 // // set resource details
1192                 // String resourceName = "CISCO4";
1193                 // String description = "description";
1194                 // ArrayList<String> resourceTags = new ArrayList<String>();
1195                 // resourceTags.add(resourceName);
1196                 // resourceTags.add("tag2");
1197                 // String category = ResourceServiceCategoriesEnum.VOIP.getValue();
1198                 // ArrayList<String> derivedFrom = new ArrayList<String>();
1199                 // derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1200                 // String vendorName = "Oracle";
1201                 // String vendorRelease = "1.5";
1202                 // String icon = "myICON";
1203                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1204                 resourceDetails.setTags(Arrays.asList(resourceDetails.getName(), "tag2"));
1205
1206                 // create resource
1207                 RestResponse restResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1208
1209                 // validate response
1210                 assertNotNull("check response object is not null after create resource", restResponse);
1211                 assertNotNull("check error code exists in response after create resource", restResponse.getErrorCode());
1212                 assertEquals("Check response code after create resource", 201, restResponse.getErrorCode().intValue());
1213
1214         }
1215
1216         @Test
1217         public void createResourceTest_empty_tag() throws Exception {
1218
1219                 // init ADMIN user
1220
1221                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1222
1223                 // set resource details
1224                 String resourceName = "CISCO4";
1225                 String description = "description";
1226                 ArrayList<String> resourceTags = new ArrayList<String>();
1227                 resourceTags.add("");
1228                 String category = ServiceCategoriesEnum.VOIP.getValue();
1229                 ArrayList<String> derivedFrom = new ArrayList<String>();
1230                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1231                 String vendorName = "Oracle";
1232                 String vendorRelease = "1.5";
1233                 String contactId = "jh0003";
1234                 String icon = "myICON";
1235
1236                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, category,
1237                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1238
1239                 // create resource
1240                 RestResponse restResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1241
1242                 // validate response
1243                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FIELD_FORMAT.name());
1244
1245                 assertNotNull("check response object is not null after create resouce", restResponse);
1246                 assertNotNull("check error code exists in response after create resource", restResponse.getErrorCode());
1247                 assertEquals("Check response code after create resource", errorInfo.getCode(), restResponse.getErrorCode());
1248
1249                 List<String> variables = Arrays.asList("Resource", "tag");
1250                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FIELD_FORMAT.name(), variables,
1251                                 restResponse.getResponse());
1252
1253                 // validate audit
1254                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1255                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
1256
1257                 String auditAction = "Create";
1258                 expectedResourceAuditJavaObject.setAction(auditAction);
1259                 expectedResourceAuditJavaObject.setPrevState("");
1260                 expectedResourceAuditJavaObject.setPrevVersion("");
1261                 expectedResourceAuditJavaObject.setCurrState("");
1262                 expectedResourceAuditJavaObject.setCurrVersion("");
1263                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1264
1265                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1266                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1267
1268                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1269
1270         }
1271
1272         @Test
1273         public void createResourceTest_with_empty_vendorName() throws Exception {
1274                 // init ADMIN user
1275                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1276
1277                 // set resource details
1278                 String resourceName = "CISCO4";
1279                 String description = "description";
1280                 ArrayList<String> resourceTags = new ArrayList<String>();
1281                 resourceTags.add(resourceName);
1282                 String category = ServiceCategoriesEnum.VOIP.getValue();
1283                 ArrayList<String> derivedFrom = new ArrayList<String>();
1284                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1285                 String vendorName = "Oracle";
1286                 String vendorRelease = "1.5";
1287                 String contactId = "jh0003";
1288                 String icon = "myICON";
1289
1290                 // set resource details
1291                 vendorName = "";
1292
1293                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1294                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1295
1296                 // create resource
1297                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1298
1299                 // validate response
1300                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_VENDOR_NAME.name());
1301
1302                 assertNotNull("check response object is not null after create resouce", restResponse2);
1303                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1304                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1305
1306                 List<String> variables = Arrays.asList();
1307                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_VENDOR_NAME.name(), variables,
1308                                 restResponse2.getResponse());
1309
1310                 // validate audit
1311                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1312                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1313                 String auditAction = "Create";
1314                 expectedResourceAuditJavaObject.setAction(auditAction);
1315                 expectedResourceAuditJavaObject.setPrevState("");
1316                 expectedResourceAuditJavaObject.setPrevVersion("");
1317                 expectedResourceAuditJavaObject.setCurrState("");
1318                 expectedResourceAuditJavaObject.setCurrVersion("");
1319                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1320
1321                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1322                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1323
1324                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1325
1326         }
1327
1328         @Test
1329         public void createResourceTest_without_vendorName() throws Exception {
1330                 // init ADMIN user
1331                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1332
1333                 // set resource details
1334                 String resourceName = "CISCO4";
1335                 String description = "description";
1336                 ArrayList<String> resourceTags = new ArrayList<String>();
1337                 resourceTags.add(resourceName);
1338                 String category = ServiceCategoriesEnum.VOIP.getValue();
1339                 ArrayList<String> derivedFrom = new ArrayList<String>();
1340                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1341                 String vendorName = "Oracle";
1342                 String vendorRelease = "1.5";
1343                 String contactId = "jh0003";
1344                 String icon = "myICON";
1345
1346                 // set resource details
1347                 vendorName = null;
1348
1349                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1350                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1351
1352                 // create resource
1353
1354                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1355
1356                 // validate response
1357                 assertNotNull("check response object is not null after create resource", restResponse2);
1358                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1359                 assertEquals("Check response code after create resource", 400, restResponse2.getErrorCode().intValue());
1360
1361                 List<String> variables = Arrays.asList();
1362                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_VENDOR_NAME.name(), variables,
1363                                 restResponse2.getResponse());
1364
1365         }
1366
1367         @Test
1368         public void createResourceTest_with_empty_vendorRelease() throws Exception {
1369                 // init ADMIN user
1370                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1371
1372                 // set resource details
1373                 String resourceName = "CISCO4";
1374                 String description = "description";
1375                 ArrayList<String> resourceTags = new ArrayList<String>();
1376                 resourceTags.add(resourceName);
1377                 String category = ServiceCategoriesEnum.VOIP.getValue();
1378                 ArrayList<String> derivedFrom = new ArrayList<String>();
1379                 derivedFrom.add("root");
1380                 String vendorName = "Oracle";
1381                 String vendorRelease = "1.5";
1382                 String contactId = "jh0003";
1383                 String icon = "myICON";
1384
1385                 // set resource details
1386                 vendorRelease = "";
1387
1388                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1389                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1390
1391                 // create resource
1392
1393                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1394
1395                 // validate response
1396
1397                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_VENDOR_RELEASE.name());
1398
1399                 assertNotNull("check response object is not null after create resouce", restResponse2);
1400                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1401                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1402
1403                 List<String> variables = Arrays.asList();
1404                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_VENDOR_RELEASE.name(), variables,
1405                                 restResponse2.getResponse());
1406
1407                 // validate audit
1408
1409                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1410                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1411
1412                 String auditAction = "Create";
1413                 expectedResourceAuditJavaObject.setAction(auditAction);
1414                 expectedResourceAuditJavaObject.setPrevState("");
1415                 expectedResourceAuditJavaObject.setPrevVersion("");
1416                 expectedResourceAuditJavaObject.setCurrState("");
1417                 expectedResourceAuditJavaObject.setCurrVersion("");
1418                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1419
1420                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1421                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1422
1423                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1424
1425         }
1426
1427         @Test
1428         public void createResourceTest_without_vendorRelease() throws Exception {
1429                 // init ADMIN user
1430                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1431
1432                 // set resource details
1433                 String resourceName = "CISCO4";
1434                 String description = "description";
1435                 ArrayList<String> resourceTags = new ArrayList<String>();
1436                 resourceTags.add(resourceName);
1437                 String category = ServiceCategoriesEnum.VOIP.getValue();
1438                 ArrayList<String> derivedFrom = new ArrayList<String>();
1439                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1440                 String vendorName = "Oracle";
1441                 String vendorRelease = "1.5";
1442                 String contactId = "jh0003";
1443                 String icon = "myICON";
1444
1445                 // set resource details
1446                 vendorRelease = null;
1447
1448                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1449                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1450
1451                 // create resource
1452
1453                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1454
1455                 // validate response
1456
1457                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_VENDOR_RELEASE.name());
1458
1459                 assertNotNull("check response object is not null after create resouce", restResponse2);
1460                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1461                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1462
1463                 List<String> variables = Arrays.asList();
1464                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_VENDOR_RELEASE.name(), variables,
1465                                 restResponse2.getResponse());
1466
1467                 // validate audit
1468
1469                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1470                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1471
1472                 String auditAction = "Create";
1473                 expectedResourceAuditJavaObject.setAction(auditAction);
1474                 expectedResourceAuditJavaObject.setPrevState("");
1475                 expectedResourceAuditJavaObject.setPrevVersion("");
1476                 expectedResourceAuditJavaObject.setCurrState("");
1477                 expectedResourceAuditJavaObject.setCurrVersion("");
1478                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1479
1480                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1481                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1482
1483                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1484
1485         }
1486
1487         @Test
1488         public void createResourceTest_with_empty_contactId() throws Exception {
1489                 // init ADMIN user
1490                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1491
1492                 // set resource details
1493                 String resourceName = "CISCO4";
1494                 String description = "description";
1495                 ArrayList<String> resourceTags = new ArrayList<String>();
1496                 resourceTags.add(resourceName);
1497                 String category = ServiceCategoriesEnum.VOIP.getValue();
1498                 ArrayList<String> derivedFrom = new ArrayList<String>();
1499                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1500                 String vendorName = "Oracle";
1501                 String vendorRelease = "1.5";
1502                 String contactId = "jh0003";
1503                 String icon = "myICON";
1504
1505                 // set resource details
1506                 contactId = "";
1507
1508                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1509                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1510
1511                 // create resource
1512
1513                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1514
1515                 // validate response
1516
1517                 ErrorInfo errorInfo = ErrorValidationUtils
1518                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_CONTACT.name());
1519
1520                 assertNotNull("check response object is not null after create resouce", restResponse2);
1521                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1522                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1523
1524                 List<String> variables = Arrays.asList("Resource");
1525                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_CONTACT.name(), variables,
1526                                 restResponse2.getResponse());
1527
1528                 // validate audit
1529
1530                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1531                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1532
1533                 String auditAction = "Create";
1534                 expectedResourceAuditJavaObject.setAction(auditAction);
1535                 expectedResourceAuditJavaObject.setPrevState("");
1536                 expectedResourceAuditJavaObject.setPrevVersion("");
1537                 expectedResourceAuditJavaObject.setCurrState("");
1538                 expectedResourceAuditJavaObject.setCurrVersion("");
1539                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1540
1541                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1542                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1543
1544                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1545
1546         }
1547
1548         @Test
1549         public void createResourceTest_without_contactId() throws Exception {
1550                 // init ADMIN user
1551                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1552
1553                 // set resource details
1554                 String resourceName = "CISCO4";
1555                 String description = "description";
1556                 ArrayList<String> resourceTags = new ArrayList<String>();
1557                 resourceTags.add(resourceName);
1558                 String category = ServiceCategoriesEnum.VOIP.getValue();
1559                 ArrayList<String> derivedFrom = new ArrayList<String>();
1560                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1561                 String vendorName = "Oracle";
1562                 String vendorRelease = "1.5";
1563                 String contactId = "jh0003";
1564                 String icon = "myICON";
1565
1566                 // set resource details
1567                 contactId = null;
1568
1569                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1570                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1571
1572                 // create resource
1573
1574                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1575
1576                 // validate response
1577
1578                 ErrorInfo errorInfo = ErrorValidationUtils
1579                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_CONTACT.name());
1580
1581                 assertNotNull("check response object is not null after create resouce", restResponse2);
1582                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1583                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1584
1585                 List<String> variables = Arrays.asList("Resource");
1586                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_CONTACT.name(), variables,
1587                                 restResponse2.getResponse());
1588
1589                 // validate audit
1590
1591                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1592                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1593
1594                 String auditAction = "Create";
1595                 expectedResourceAuditJavaObject.setAction(auditAction);
1596                 expectedResourceAuditJavaObject.setPrevState("");
1597                 expectedResourceAuditJavaObject.setPrevVersion("");
1598                 expectedResourceAuditJavaObject.setCurrState("");
1599                 expectedResourceAuditJavaObject.setCurrVersion("");
1600                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1601
1602                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1603                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1604
1605                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1606
1607         }
1608
1609         @Test
1610         public void createResourceTest_with_empty_icon() throws Exception {
1611                 // init ADMIN user
1612                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1613
1614                 // set resource details
1615                 String resourceName = "CISCO4";
1616                 String description = "description";
1617                 ArrayList<String> resourceTags = new ArrayList<String>();
1618                 resourceTags.add(resourceName);
1619                 String category = ServiceCategoriesEnum.VOIP.getValue();
1620                 ArrayList<String> derivedFrom = new ArrayList<String>();
1621                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1622                 String vendorName = "Oracle";
1623                 String vendorRelease = "1.5";
1624                 String contactId = "jh0003";
1625                 String icon = "myICON";
1626
1627                 // set resource details
1628                 icon = "";
1629
1630                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1631                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1632
1633                 // create resource
1634
1635                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1636
1637                 // validate response
1638
1639                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_ICON.name());
1640
1641                 assertNotNull("check response object is not null after create resouce", restResponse2);
1642                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1643                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1644
1645                 List<String> variables = Arrays.asList("Resource");
1646                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_ICON.name(), variables,
1647                                 restResponse2.getResponse());
1648
1649                 // validate audit
1650
1651                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1652                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1653
1654                 String auditAction = "Create";
1655                 expectedResourceAuditJavaObject.setAction(auditAction);
1656                 expectedResourceAuditJavaObject.setPrevState("");
1657                 expectedResourceAuditJavaObject.setPrevVersion("");
1658                 expectedResourceAuditJavaObject.setCurrState("");
1659                 expectedResourceAuditJavaObject.setCurrVersion("");
1660                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1661
1662                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1663                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1664
1665                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1666
1667         }
1668
1669         @Test
1670         public void createResourceTest_without_icon() throws Exception {
1671                 // init ADMIN user
1672                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1673
1674                 // set resource details
1675                 String resourceName = "CISCO4";
1676                 String description = "description";
1677                 ArrayList<String> resourceTags = new ArrayList<String>();
1678                 resourceTags.add(resourceName);
1679                 String category = ServiceCategoriesEnum.VOIP.getValue();
1680                 ArrayList<String> derivedFrom = new ArrayList<String>();
1681                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1682                 String vendorName = "Oracle";
1683                 String vendorRelease = "1.5";
1684                 String contactId = "jh0003";
1685                 String icon = "myICON";
1686
1687                 // set resource details
1688                 icon = null;
1689
1690                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1691                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1692
1693                 // create resource
1694
1695                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1696
1697                 // validate response
1698
1699                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_ICON.name());
1700
1701                 assertNotNull("check response object is not null after create resouce", restResponse2);
1702                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1703                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1704
1705                 List<String> variables = Arrays.asList("Resource");
1706                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_ICON.name(), variables,
1707                                 restResponse2.getResponse());
1708
1709                 // validate audit
1710
1711                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1712                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1713
1714                 String auditAction = "Create";
1715                 expectedResourceAuditJavaObject.setAction(auditAction);
1716                 expectedResourceAuditJavaObject.setPrevState("");
1717                 expectedResourceAuditJavaObject.setPrevVersion("");
1718                 expectedResourceAuditJavaObject.setCurrState("");
1719                 expectedResourceAuditJavaObject.setCurrVersion("");
1720                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1721
1722                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1723                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1724
1725                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1726
1727         }
1728
1729         @Test
1730         public void createResourceTest_with_empty_description() throws Exception {
1731                 // init ADMIN user
1732                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1733
1734                 // set resource details
1735                 String resourceName = "CISCO4";
1736                 String description = "description";
1737                 ArrayList<String> resourceTags = new ArrayList<String>();
1738                 resourceTags.add(resourceName);
1739                 String category = ServiceCategoriesEnum.VOIP.getValue();
1740                 ArrayList<String> derivedFrom = new ArrayList<String>();
1741                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1742                 String vendorName = "Oracle";
1743                 String vendorRelease = "1.5";
1744                 String contactId = "jh0003";
1745                 String icon = "myICON";
1746
1747                 // set resource details
1748                 description = "";
1749
1750                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1751                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1752
1753                 // create resource
1754
1755                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1756
1757                 // validate response
1758
1759                 ErrorInfo errorInfo = ErrorValidationUtils
1760                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name());
1761
1762                 assertNotNull("check response object is not null after create resouce", restResponse2);
1763                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1764                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1765
1766                 List<String> variables = Arrays.asList("Resource");
1767                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name(), variables,
1768                                 restResponse2.getResponse());
1769
1770                 // validate audit
1771
1772                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1773                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1774
1775                 String auditAction = "Create";
1776                 expectedResourceAuditJavaObject.setAction(auditAction);
1777                 expectedResourceAuditJavaObject.setPrevState("");
1778                 expectedResourceAuditJavaObject.setPrevVersion("");
1779                 expectedResourceAuditJavaObject.setCurrState("");
1780                 expectedResourceAuditJavaObject.setCurrVersion("");
1781                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1782
1783                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1784                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1785
1786                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1787
1788         }
1789
1790         @Test
1791         public void createResourceTest_without_description() throws Exception {
1792                 // init ADMIN user
1793                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1794
1795                 // set resource details
1796                 String resourceName = "CISCO4";
1797                 String description = "description";
1798                 ArrayList<String> resourceTags = new ArrayList<String>();
1799                 resourceTags.add(resourceName);
1800                 String category = ServiceCategoriesEnum.VOIP.getValue();
1801                 ArrayList<String> derivedFrom = new ArrayList<String>();
1802                 derivedFrom.add(NormativeTypesEnum.ROOT.getNormativeName());
1803                 String vendorName = "Oracle";
1804                 String vendorRelease = "1.5";
1805                 String contactId = "jh0003";
1806                 String icon = "myICON";
1807
1808                 // set resource details
1809                 description = null;
1810
1811                 ResourceReqDetails resourceDetails2 = new ResourceReqDetails(resourceName, description, resourceTags, category,
1812                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
1813
1814                 // create resource
1815
1816                 RestResponse restResponse2 = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
1817
1818                 // validate response
1819
1820                 ErrorInfo errorInfo = ErrorValidationUtils
1821                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name());
1822
1823                 assertNotNull("check response object is not null after create resouce", restResponse2);
1824                 assertNotNull("check error code exists in response after create resource", restResponse2.getErrorCode());
1825                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse2.getErrorCode());
1826
1827                 List<String> variables = Arrays.asList("Resource");
1828                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name(), variables,
1829                                 restResponse2.getResponse());
1830
1831                 // validate audit
1832
1833                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1834                                 .constructFieldsForAuditValidation(resourceDetails2, resourceVersion);
1835
1836                 String auditAction = "Create";
1837                 expectedResourceAuditJavaObject.setAction(auditAction);
1838                 expectedResourceAuditJavaObject.setPrevState("");
1839                 expectedResourceAuditJavaObject.setPrevVersion("");
1840                 expectedResourceAuditJavaObject.setCurrState("");
1841                 expectedResourceAuditJavaObject.setCurrVersion("");
1842                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1843
1844                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1845                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1846
1847                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1848
1849         }
1850
1851         @Test
1852         public void createAndGetResourceByNameAndVersion() throws Exception {
1853
1854                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1855                 ResourceReqDetails resourceDetailsComp = ElementFactory.getDefaultResource("testresourceComp",
1856                                 NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, sdncModifierDetails.getUserId());
1857
1858                 // create resource
1859                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetailsComp, sdncModifierDetails);
1860                 // validate response
1861                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
1862
1863                 String resourceVersion = "0.1";
1864                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetailsComp,
1865                                 resourceVersion);
1866                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1867                 resourceRespJavaObject.setAbstractt("false");
1868                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
1869
1870                 // validate get response
1871                 RestResponse resourceGetResponse = ResourceRestUtils.getResourceByNameAndVersion(
1872                                 sdncModifierDetails.getUserId(), resourceDetailsComp.getName(), resourceDetailsComp.getVersion());
1873                 assertEquals("Check response code after delete resource", 200, resourceGetResponse.getErrorCode().intValue());
1874                 // Resource resource =
1875                 // ResourceRestUtils.parseResourceFromListResp(resourceGetResponse);
1876                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
1877                 // resourceDetailsComp.setUniqueId(resource.getUniqueId());
1878
1879         }
1880
1881         @Test
1882         public void createResourceResourceTypeNotExistsTest() throws Exception {
1883
1884                 // init ADMIN user
1885                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1886
1887                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1888                 String resourceType = "NOT EXISTS";
1889                 resourceDetails.setResourceType(resourceType);
1890                 // create resource
1891                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1892
1893                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_CONTENT.name());
1894
1895                 assertNotNull("check response object is not null after create resouce", createResponse);
1896                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
1897                 assertEquals("Check response code after create service", errorInfo.getCode(), createResponse.getErrorCode());
1898
1899                 List<String> variables = new ArrayList<>();
1900                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), variables,
1901                                 createResponse.getResponse());
1902
1903                 // validate audit
1904                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = Convertor
1905                                 .constructFieldsForAuditValidation(resourceDetails, resourceVersion);
1906                 String auditAction = "Create";
1907                 expectedResourceAuditJavaObject.setAction(auditAction);
1908                 expectedResourceAuditJavaObject.setPrevState("");
1909                 expectedResourceAuditJavaObject.setPrevVersion("");
1910                 expectedResourceAuditJavaObject.setCurrState("");
1911                 expectedResourceAuditJavaObject.setCurrVersion("");
1912                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1913
1914                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1915                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1916                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1917         }
1918
1919         @Test
1920         public void createResourceResourceTypeEmptyTest() throws Exception {
1921
1922                 // init ADMIN user
1923                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1924
1925                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1926                 // String resourceType = "";
1927                 // resourceDetails.setResourceType(resourceType);
1928                 // create resource
1929                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1930
1931                 // ErrorInfo errorInfo =
1932                 // ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_CONTENT.name());
1933                 //
1934                 // assertNotNull("check response object is not null after create
1935                 // resouce", createResponse);
1936                 // assertNotNull("check error code exists in response after create
1937                 // resource", createResponse.getErrorCode());
1938                 // assertEquals("Check response code after create service",
1939                 // errorInfo.getCode(), createResponse.getErrorCode());
1940                 //
1941                 // List<String> variables = new ArrayList<>();
1942                 // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(),
1943                 // variables, createResponse.getResponse());
1944                 //
1945                 // // validate audit
1946                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1947                 // Convertor.constructFieldsForAuditValidation(resourceDetails,
1948                 // resourceVersion);
1949                 // String auditAction = "Create";
1950                 // expectedResourceAuditJavaObject.setAction(auditAction);
1951                 // expectedResourceAuditJavaObject.setPrevState("");
1952                 // expectedResourceAuditJavaObject.setPrevVersion("");
1953                 // expectedResourceAuditJavaObject.setCurrState("");
1954                 // expectedResourceAuditJavaObject.setCurrVersion("");
1955                 // expectedResourceAuditJavaObject.setResourceName("");
1956                 // expectedResourceAuditJavaObject.setModifierUid(ElementFactory.getDefaultUser(UserRoleEnum.ADMIN).getUserId());
1957                 // expectedResourceAuditJavaObject.setModifierName(ElementFactory.getDefaultUser(UserRoleEnum.ADMIN).getFullName());
1958                 // expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1959                 //
1960                 // String auditDesc =
1961                 // AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1962                 // expectedResourceAuditJavaObject.setDesc(auditDesc);
1963                 // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1964                 // auditAction, null, false);
1965         }
1966
1967         @Test
1968         public void checkInvariantUuidIsImmutable() throws Exception {
1969                 // choose the user to create resource
1970                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1971                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1972                 String invariantUuidDefinedByUser = "!!!!!!!!!!!!!!!!!!!!!!!!";
1973                 resourceDetails.setInvariantUUID(invariantUuidDefinedByUser);
1974                 String resourceName = resourceDetails.getName();
1975                 resourceDetails.setTags(Arrays.asList(resourceName, resourceName, resourceName, resourceName, "tag2", "tag2"));
1976                 // create resource
1977                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
1978                 BaseRestUtils.checkStatusCode(createResponse, "create request failed", false, 201);
1979                 // validate response
1980                 assertNotNull("check response object is not null after create resource", createResponse);
1981                 assertNotNull("check error code exists in response after create resource", createResponse.getErrorCode());
1982                 assertEquals("Check response code after create resource", 201, createResponse.getErrorCode().intValue());
1983
1984                 Resource resourceCreation = ResponseParser.convertResourceResponseToJavaObject(createResponse.getResponse());
1985                 String invariantUUIDcreation = resourceCreation.getInvariantUUID();
1986                 // validate response
1987                 ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
1988                                 resourceVersion);
1989                 resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1990                 resourceRespJavaObject.setAbstractt("false");
1991                 ResourceValidationUtils.validateResp(createResponse, resourceRespJavaObject);
1992
1993                 // validate get response
1994                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncUserDetails,
1995                                 resourceDetails.getUniqueId());
1996                 BaseRestUtils.checkSuccess(resourceGetResponse);
1997                 Resource resourceGetting = ResponseParser
1998                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
1999                 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
2000                 String invariantUUIDgetting = resourceGetting.getInvariantUUID();
2001                 assertEquals(invariantUUIDcreation, invariantUUIDgetting);
2002
2003                 // Update resource with new invariant UUID
2004                 RestResponse restResponseUpdate = ResourceRestUtils.updateResourceMetadata(resourceDetails, sdncUserDetails,
2005                                 resourceDetails.getUniqueId());
2006                 BaseRestUtils.checkSuccess(restResponseUpdate);
2007                 Resource updatedResource = ResponseParser.convertResourceResponseToJavaObject(restResponseUpdate.getResponse());
2008                 String invariantUUIDupdating = updatedResource.getInvariantUUID();
2009                 assertEquals(invariantUUIDcreation, invariantUUIDupdating);
2010
2011                 // Do checkin
2012                 RestResponse restResponseCheckin = LifecycleRestUtils.changeResourceState(resourceDetails, sdncUserDetails,
2013                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
2014                 BaseRestUtils.checkSuccess(restResponseCheckin);
2015                 Resource checkinResource = ResponseParser
2016                                 .convertResourceResponseToJavaObject(restResponseCheckin.getResponse());
2017                 String invariantUUIDcheckin = checkinResource.getInvariantUUID();
2018                 String version = checkinResource.getVersion();
2019                 assertEquals(invariantUUIDcreation, invariantUUIDcheckin);
2020                 assertEquals(version, "0.1");
2021
2022                 // Do checkout
2023                 RestResponse restResponseCheckout = LifecycleRestUtils.changeResourceState(resourceDetails, sdncUserDetails,
2024                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
2025                 BaseRestUtils.checkSuccess(restResponseCheckout);
2026                 Resource ResourceResource = ResponseParser
2027                                 .convertResourceResponseToJavaObject(restResponseCheckout.getResponse());
2028                 String invariantUUIDcheckout = ResourceResource.getInvariantUUID();
2029                 version = ResourceResource.getVersion();
2030                 assertEquals(invariantUUIDcreation, invariantUUIDcheckout);
2031                 assertEquals(version, "0.2");
2032
2033                 // do certification request
2034                 RestResponse restResponseCertificationRequest = LifecycleRestUtils.changeResourceState(resourceDetails,
2035                                 sdncUserDetails, resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
2036                 BaseRestUtils.checkSuccess(restResponseCertificationRequest);
2037                 Resource certificationRequestResource = ResponseParser
2038                                 .convertResourceResponseToJavaObject(restResponseCertificationRequest.getResponse());
2039                 String invariantUUIDcertificationRequest = certificationRequestResource.getInvariantUUID();
2040                 version = certificationRequestResource.getVersion();
2041                 assertEquals(invariantUUIDcreation, invariantUUIDcertificationRequest);
2042                 assertEquals(version, "0.2");
2043
2044                 // start certification
2045                 RestResponse restResponseStartCertification = LifecycleRestUtils.changeResourceState(resourceDetails,
2046                                 sdncUserDetails, resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
2047                 BaseRestUtils.checkSuccess(restResponseStartCertification);
2048                 Resource startCertificationRequestResource = ResponseParser
2049                                 .convertResourceResponseToJavaObject(restResponseStartCertification.getResponse());
2050                 String invariantUUIDStartCertification = startCertificationRequestResource.getInvariantUUID();
2051                 version = startCertificationRequestResource.getVersion();
2052                 assertEquals(invariantUUIDcreation, invariantUUIDStartCertification);
2053                 assertEquals(version, "0.2");
2054
2055                 // certify
2056                 RestResponse restResponseCertify = LifecycleRestUtils.changeResourceState(resourceDetails, sdncUserDetails,
2057                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
2058                 BaseRestUtils.checkSuccess(restResponseCertify);
2059                 Resource certifyResource = ResponseParser
2060                                 .convertResourceResponseToJavaObject(restResponseCertify.getResponse());
2061                 String invariantUUIDcertify = certifyResource.getInvariantUUID();
2062                 version = certifyResource.getVersion();
2063                 assertEquals(invariantUUIDcreation, invariantUUIDcertify);
2064                 assertEquals(version, "1.0");
2065
2066         }
2067
2068         // US672129 BENNY
2069
2070         private void getResourceValidateInvariantUuid(String resourceUniqueId, String invariantUUIDcreation)
2071                         throws Exception {
2072                 RestResponse getResource = ResourceRestUtils.getResource(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2073                                 resourceUniqueId);
2074                 BaseRestUtils.checkSuccess(getResource);
2075                 Resource resource = ResponseParser.parseToObjectUsingMapper(getResource.getResponse(), Resource.class);
2076                 assertEquals(invariantUUIDcreation, resource.getInvariantUUID());
2077         }
2078
2079         @Test
2080         public void resourceInvariantUuid() throws Exception {
2081
2082                 User designerUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
2083                 User testerUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
2084                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResourceByType("VF200", NormativeTypesEnum.ROOT,
2085                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, designerUser.getUserId(), ResourceTypeEnum.VF.toString());
2086                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService("newtestservice1",
2087                                 ServiceCategoriesEnum.MOBILITY, designerUser.getUserId());
2088
2089                 // ResourceReqDetails resourceDetails =
2090                 // ElementFactory.getDefaultResource();
2091                 resourceDetails.setInvariantUUID("kokomoko");
2092                 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, designerUser);
2093                 assertEquals("Check response code after create resource", BaseRestUtils.STATUS_CODE_CREATED,
2094                                 createResponse.getErrorCode().intValue());
2095                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResponse.getResponse(), Resource.class);
2096                 String invariantUUIDcreation = resource.getInvariantUUID(); // generated
2097                                                                                                                                         // when the
2098                                                                                                                                         // component
2099                                                                                                                                         // is
2100                                                                                                                                         // created
2101                                                                                                                                         // and never
2102                                                                                                                                         // changed
2103                 // get resource and verify InvariantUuid is not changed
2104                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2105
2106                 // Update resource with new invariant UUID
2107                 resourceDetails.setInvariantUUID("1234567890");
2108                 RestResponse updateResponse = ResourceRestUtils.updateResourceMetadata(resourceDetails, designerUser,
2109                                 resourceDetails.getUniqueId());
2110                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
2111                                 updateResponse.getErrorCode().intValue());
2112                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2113
2114                 // checkIn resource
2115                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2116                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
2117                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2118                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2119                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2120
2121                 // checkIn resource
2122                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2123                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
2124                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2125                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2126                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2127                 // certification request
2128                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2129                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
2130                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2131                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2132                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2133                 // start certification
2134                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUser,
2135                                 LifeCycleStatesEnum.STARTCERTIFICATION);
2136                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2137                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2138                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2139                 // certify
2140                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUser, LifeCycleStatesEnum.CERTIFY);
2141                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2142                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2143                 getResourceValidateInvariantUuid(resource.getUniqueId(), invariantUUIDcreation);
2144                 // update resource
2145                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2146                                 LifeCycleStatesEnum.CHECKOUT);
2147                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2148                 resourceDetails.setDescription("updatedDescription");
2149                 resourceDetails.setVendorRelease("1.2.3.4");
2150                 updateResponse = ResourceRestUtils.updateResourceMetadata(resourceDetails, designerUser,
2151                                 resourceDetails.getUniqueId());
2152                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, updateResponse.getErrorCode().intValue());
2153                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2154
2155                 // certification request
2156                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2157                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
2158                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2159                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2160
2161                 // checkout resource
2162                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2163                                 LifeCycleStatesEnum.CHECKOUT);
2164                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2165                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2166
2167                 // certification request
2168                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2169                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
2170                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2171                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2172                 // start certification
2173                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUser,
2174                                 LifeCycleStatesEnum.STARTCERTIFICATION);
2175                 assertEquals(STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2176                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2177
2178                 // cancel certification
2179                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUser,
2180                                 LifeCycleStatesEnum.CANCELCERTIFICATION);
2181                 assertEquals(STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2182                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2183
2184                 // start certification
2185                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUser,
2186                                 LifeCycleStatesEnum.STARTCERTIFICATION);
2187                 assertEquals(STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2188                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2189
2190                 // failure
2191                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUser,
2192                                 LifeCycleStatesEnum.FAILCERTIFICATION);
2193                 assertEquals(STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2194                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2195
2196                 // upload artifact
2197                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2198                                 LifeCycleStatesEnum.CHECKOUT);
2199                 ArtifactReqDetails artifactDetails = ElementFactory.getDefaultArtifact();
2200                 ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails, designerUser,
2201                                 resourceDetails.getUniqueId());
2202                 assertEquals(STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2203                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2204
2205                 // checkIn resource
2206                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUser,
2207                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
2208                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2209                 // create instance
2210                 RestResponse createServiceResponse = ServiceRestUtils.createService(serviceDetails, designerUser);
2211                 ResourceRestUtils.checkCreateResponse(createServiceResponse);
2212                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory
2213                                 .getComponentResourceInstance(resourceDetails);
2214                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
2215                                 resourceInstanceReqDetails, designerUser, serviceDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
2216                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_CREATED,
2217                                 createResourceInstanceResponse.getErrorCode().intValue());
2218                 getResourceValidateInvariantUuid(resourceDetails.getUniqueId(), invariantUUIDcreation);
2219
2220         }
2221
2222 }