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

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