test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/resource/CreateResourceApiTest.java

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