gerrit.onap Code Review - sdc.git/blob

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