asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/category/SubCategoriesTest.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.category;
  22
  23 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.PRODUCT_COMPONENT_TYPE;
  24 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.RESOURCE_COMPONENT_TYPE;
  25 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.SERVICE_COMPONENT_TYPE;
  26 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_ALREADY_EXISTS;
  27 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_CREATED;
  28 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_INVALID_CONTENT;
  29 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_MISSING_INFORMATION;
  30 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_NOT_FOUND;
  31 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION;
  32 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  33 import static org.testng.AssertJUnit.assertEquals;
  34
  35 import java.util.ArrayList;
  36 import java.util.List;
  37
  38 import org.junit.Rule;
  39 import org.junit.rules.TestName;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.model.User;
  42 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  43 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  44 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  45 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  46 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  47 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedCategoryAudit;
  48 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  49 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  50 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  51 import org.openecomp.sdc.ci.tests.utils.rest.CategoryRestUtils;
  52 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  53 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  54 import org.openecomp.sdc.ci.tests.utils.validation.CategoryValidationUtils;
  55 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  56 import org.testng.annotations.BeforeMethod;
  57 import org.testng.annotations.Test;
  58
  59 public class SubCategoriesTest extends ComponentBaseTest {
  60
  61         protected static final String ADD_SUB_CATEGORY = "AddSubCategory";
  62         protected static final String CATEGORY = "category";
  63         protected static final String SUB_CATEGORY = "sub-category";
  64
  65         protected static final String AUDIT_SERVICE_TYPE = "Service";
  66         protected static final String AUDIT_RESOURCE_TYPE = "Resource";
  67         protected static final String AUDIT_PRODUCT_TYPE = "Product";
  68         protected static final String GET_CATEGORY_HIERARCHY = "GetCategoryHierarchy";
  69         protected static User sdncAdminUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  70         protected static User sdncAdminUserDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  71         protected static User sdncDesignerUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  72         protected static User sdncTesterUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  73         protected static User sdncGovernorUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
  74         protected static User sdncOpsUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
  75         protected static User sdncProductManagerUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
  76         protected static User sdncProductStrategistUserDetails = ElementFactory
  77                         .getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1);
  78
  79         public SubCategoriesTest() {
  80                 super(name, SubCategoriesTest.class.getName());
  81         }
  82
  83         @Rule
  84         public static TestName name = new TestName();
  85
  86         private CategoryDefinition resourceCategoryDefinition;
  87         private CategoryDefinition resourceCategoryDefinition1;
  88         private CategoryDefinition serviceCategoryDefinition;
  89         private CategoryDefinition productCategoryDefinition;
  90         private CategoryDefinition productCategoryDefinition1;
  91         private CategoryDefinition resourceCategoryDefinition100;
  92         private CategoryDefinition productCategoryDefinition200;
  93
  94         private SubCategoryDefinition resourceSubCategoryDefinition;
  95         private SubCategoryDefinition resourceSubCategoryDefinition1;
  96         private SubCategoryDefinition serviceSubCategoryDefinition;
  97         private SubCategoryDefinition productSubCategoryDefinition;
  98         private SubCategoryDefinition productSubCategoryDefinition1;
  99
 100         @BeforeMethod
 101         public void init() throws Exception {
 102
 103                 // Category setup
 104                 resourceCategoryDefinition = new CategoryDefinition();
 105                 resourceCategoryDefinition1 = new CategoryDefinition();
 106                 serviceCategoryDefinition = new CategoryDefinition();
 107                 productCategoryDefinition = new CategoryDefinition();
 108                 productCategoryDefinition1 = new CategoryDefinition();
 109                 resourceCategoryDefinition100 = new CategoryDefinition(); // for
 110                                                                                                                                         // negative
 111                                                                                                                                         // tests
 112                 productCategoryDefinition200 = new CategoryDefinition(); // for negative
 113                                                                                                                                         // tests
 114
 115                 resourceCategoryDefinition.setName("Category1");
 116                 resourceCategoryDefinition1.setName("Category2");
 117                 serviceCategoryDefinition.setName("Category1");
 118                 productCategoryDefinition.setName("Category2");
 119                 productCategoryDefinition1.setName("Category3");
 120                 resourceCategoryDefinition100.setName("Category100");
 121                 productCategoryDefinition200.setName("Category100");
 122
 123                 // Subcategory setup
 124                 resourceSubCategoryDefinition = new SubCategoryDefinition();
 125                 resourceSubCategoryDefinition1 = new SubCategoryDefinition();
 126                 serviceSubCategoryDefinition = new SubCategoryDefinition();
 127                 productSubCategoryDefinition = new SubCategoryDefinition();
 128                 productSubCategoryDefinition1 = new SubCategoryDefinition();
 129
 130                 resourceSubCategoryDefinition.setName("Resource-subcat");
 131                 // Service sub - for negative testing since it's not allowed
 132                 serviceSubCategoryDefinition.setName("Service-subcat");
 133                 productSubCategoryDefinition.setName("Product-subcat");
 134
 135                 // Init resource category
 136                 RestResponse createCategory = CategoryRestUtils.createCategory(resourceCategoryDefinition, sdncAdminUserDetails,
 137                                 RESOURCE_COMPONENT_TYPE);
 138                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 139                                 createCategory.getErrorCode().intValue());
 140                 CategoryDefinition category = ResponseParser.parseToObject(createCategory.getResponse(),
 141                                 CategoryDefinition.class);
 142                 assertEquals("Check category name after creating category ", resourceCategoryDefinition.getName(),
 143                                 category.getName());
 144                 resourceCategoryDefinition = category;
 145
 146                 // Init resource category1
 147                 createCategory = CategoryRestUtils.createCategory(resourceCategoryDefinition1, sdncAdminUserDetails,
 148                                 RESOURCE_COMPONENT_TYPE);
 149                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 150                                 createCategory.getErrorCode().intValue());
 151                 category = ResponseParser.parseToObject(createCategory.getResponse(), CategoryDefinition.class);
 152                 assertEquals("Check category name after creating category ", resourceCategoryDefinition1.getName(),
 153                                 category.getName());
 154                 resourceCategoryDefinition1 = category;
 155
 156                 // Init service category
 157                 createCategory = CategoryRestUtils.createCategory(serviceCategoryDefinition, sdncAdminUserDetails,
 158                                 SERVICE_COMPONENT_TYPE);
 159                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 160                                 createCategory.getErrorCode().intValue());
 161                 category = ResponseParser.parseToObject(createCategory.getResponse(), CategoryDefinition.class);
 162                 assertEquals("Check category name after creating category ", serviceCategoryDefinition.getName(),
 163                                 category.getName());
 164                 serviceCategoryDefinition = category;
 165
 166                 // Init product category
 167                 createCategory = CategoryRestUtils.createCategory(productCategoryDefinition, sdncProductStrategistUserDetails,
 168                                 PRODUCT_COMPONENT_TYPE);
 169                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 170                                 createCategory.getErrorCode().intValue());
 171                 category = ResponseParser.parseToObject(createCategory.getResponse(), CategoryDefinition.class);
 172                 assertEquals("Check category name after creating category ", productCategoryDefinition.getName(),
 173                                 category.getName());
 174                 productCategoryDefinition = category;
 175
 176                 // Init product category1
 177                 createCategory = CategoryRestUtils.createCategory(productCategoryDefinition1, sdncProductStrategistUserDetails,
 178                                 PRODUCT_COMPONENT_TYPE);
 179                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 180                                 createCategory.getErrorCode().intValue());
 181                 category = ResponseParser.parseToObject(createCategory.getResponse(), CategoryDefinition.class);
 182                 assertEquals("Check category name after creating category ", productCategoryDefinition1.getName(),
 183                                 category.getName());
 184                 productCategoryDefinition1 = category;
 185
 186         }
 187
 188         @Test
 189         public void createResourceSubCategorySuccess() throws Exception {
 190                 createSubCategorySuccess(resourceCategoryDefinition, resourceSubCategoryDefinition, sdncAdminUserDetails,
 191                                 RESOURCE_COMPONENT_TYPE, AUDIT_RESOURCE_TYPE);
 192         }
 193
 194         @Test
 195         public void createProductSubCategorySuccess() throws Exception {
 196                 createSubCategorySuccess(productCategoryDefinition, productSubCategoryDefinition,
 197                                 sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE, AUDIT_PRODUCT_TYPE);
 198         }
 199
 200         @Test
 201         public void createProductSubCategoryTwoCategoriesCaseInsensitive() throws Exception {
 202                 String componentType = PRODUCT_COMPONENT_TYPE;
 203                 String auditType = AUDIT_PRODUCT_TYPE;
 204                 User user = sdncProductStrategistUserDetails;
 205                 // Create product sub Category2-->Product-subcat
 206                 createSubCategorySuccess(productCategoryDefinition, productSubCategoryDefinition, user, componentType,
 207                                 auditType);
 208                 DbUtils.deleteFromEsDbByPattern("_all");
 209
 210                 // Create product sub Category3-->PRoDUCT-SUBcat
 211                 // Should be created Category3-->Product-subcat
 212                 productSubCategoryDefinition1.setName("PRoDUCT-SUBcat");
 213                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition1,
 214                                 productCategoryDefinition1, user, componentType);
 215                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 216                                 createSubCategoryRest.getErrorCode().intValue());
 217                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(user, componentType);
 218                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 219                                 getAllCategoriesRest.getErrorCode().intValue());
 220                 productSubCategoryDefinition1.setName(productSubCategoryDefinition.getName());
 221                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 222                                 productCategoryDefinition1.getUniqueId(), productSubCategoryDefinition1);
 223                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, productCategoryDefinition1,
 224                                 productSubCategoryDefinition1, user, STATUS_CODE_CREATED, auditType);
 225         }
 226
 227         // Benny
 228         @Test
 229         public void createResourceSubCategoryAlreadyExistInDifferentResourceCategory() throws Exception {
 230                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 231                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 232                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 233                                 createSubCategoryRest.getErrorCode().intValue());
 234                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 235                                 RESOURCE_COMPONENT_TYPE);
 236                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 237                                 getAllCategoriesRest.getErrorCode().intValue());
 238                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 239                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 240                 // Audit validation
 241                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 242                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 243                 DbUtils.deleteFromEsDbByPattern("_all");
 244                 resourceSubCategoryDefinition1.setName("ResourcE-subCat");
 245                 createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition1,
 246                                 resourceCategoryDefinition1, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 247                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 248                                 createSubCategoryRest.getErrorCode().intValue());
 249                 getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 250                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 251                                 getAllCategoriesRest.getErrorCode().intValue());
 252                 resourceSubCategoryDefinition1.setName(resourceSubCategoryDefinition.getName());
 253                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 254                                 resourceCategoryDefinition1.getUniqueId(), resourceSubCategoryDefinition1); // also
 255                                                                                                                                                                                         // set
 256                                                                                                                                                                                         // catalog
 257                                                                                                                                                                                         // uniqeId
 258                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition1,
 259                                 resourceSubCategoryDefinition1, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 260         }
 261
 262         @Test
 263         public void createProductSubCategoryAlreadyExistInDifferentProductCategory() throws Exception {
 264                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 265                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 266                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 267                                 createSubCategoryRest.getErrorCode().intValue());
 268                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 269                                 PRODUCT_COMPONENT_TYPE);
 270                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 271                                 getAllCategoriesRest.getErrorCode().intValue());
 272                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 273                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 274                 // Audit validation
 275                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, productCategoryDefinition,
 276                                 productSubCategoryDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED,
 277                                 AUDIT_PRODUCT_TYPE);
 278                 DbUtils.deleteFromEsDbByPattern("_all");
 279                 productSubCategoryDefinition1.setName("PRoDUCT-SUBcat");
 280                 createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition1,
 281                                 productCategoryDefinition1, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 282                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 283                                 createSubCategoryRest.getErrorCode().intValue());
 284                 getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
 285                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 286                                 getAllCategoriesRest.getErrorCode().intValue());
 287                 productSubCategoryDefinition1.setName(productSubCategoryDefinition.getName());
 288                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 289                                 productCategoryDefinition1.getUniqueId(), productSubCategoryDefinition1); // also
 290                                                                                                                                                                                         // set
 291                                                                                                                                                                                         // catalog
 292                                                                                                                                                                                         // uniqeId
 293                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, productCategoryDefinition1,
 294                                 productSubCategoryDefinition1, sdncProductStrategistUserDetails, STATUS_CODE_CREATED,
 295                                 AUDIT_PRODUCT_TYPE);
 296         }
 297
 298         @Test
 299         public void createResourceSubCategoryAlreadyExistInCategory() throws Exception {
 300                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 301                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 302                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 303                                 createSubCategoryRest.getErrorCode().intValue());
 304                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 305                                 RESOURCE_COMPONENT_TYPE);
 306                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 307                                 getAllCategoriesRest.getErrorCode().intValue());
 308                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 309                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 310                 // Audit validation
 311                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 312                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 313                 DbUtils.deleteFromEsDbByPattern("_all");
 314                 resourceSubCategoryDefinition1.setName("ResourcE-subCat");
 315                 createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition1,
 316                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 317                 assertEquals("Check response code after create Sub category", STATUS_CODE_ALREADY_EXISTS,
 318                                 createSubCategoryRest.getErrorCode().intValue());
 319                 getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 320                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 321                                 getAllCategoriesRest.getErrorCode().intValue());
 322                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 323                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 324                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 325                                 resourceSubCategoryDefinition1, sdncAdminUserDetails,
 326                                 ActionStatus.COMPONENT_SUB_CATEGORY_EXISTS_FOR_CATEGORY, STATUS_CODE_ALREADY_EXISTS,
 327                                 AUDIT_RESOURCE_TYPE, AUDIT_RESOURCE_TYPE, resourceSubCategoryDefinition1.getName(),
 328                                 resourceCategoryDefinition.getName());
 329         }
 330
 331         @Test
 332         public void createProductSubCategoryAlreadyExistInCategory() throws Exception {
 333                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 334                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 335                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 336                                 createSubCategoryRest.getErrorCode().intValue());
 337                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 338                                 PRODUCT_COMPONENT_TYPE);
 339                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 340                                 getAllCategoriesRest.getErrorCode().intValue());
 341                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 342                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 343                 // Audit validation
 344                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, productCategoryDefinition,
 345                                 productSubCategoryDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED,
 346                                 AUDIT_PRODUCT_TYPE);
 347                 DbUtils.deleteFromEsDbByPattern("_all");
 348                 productSubCategoryDefinition1.setName("ProducT-subCat");
 349                 createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition1,
 350                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 351                 assertEquals("Check response code after create Sub category", STATUS_CODE_ALREADY_EXISTS,
 352                                 createSubCategoryRest.getErrorCode().intValue());
 353                 getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
 354                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 355                                 getAllCategoriesRest.getErrorCode().intValue());
 356                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 357                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 358                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, productCategoryDefinition,
 359                                 productSubCategoryDefinition1, sdncProductStrategistUserDetails,
 360                                 ActionStatus.COMPONENT_SUB_CATEGORY_EXISTS_FOR_CATEGORY, STATUS_CODE_ALREADY_EXISTS, AUDIT_PRODUCT_TYPE,
 361                                 AUDIT_PRODUCT_TYPE, productSubCategoryDefinition1.getName(), productCategoryDefinition.getName());
 362         }
 363
 364         @Test
 365         public void addSameNormalizedSubCategoryNameForRecourceAndProductCategory() throws Exception {
 366                 // add sub-categoty name "SubCaT" to resource category
 367                 // add sub-categoty name "SUbcAt" to product category
 368                 resourceSubCategoryDefinition.setName("SubCaT"); // normalized 'subcat'
 369                 productSubCategoryDefinition.setName("SUbcAt"); // normalized 'subcat'
 370                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 371                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 372                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 373                                 createSubCategoryRest.getErrorCode().intValue());
 374                 // Audit validation
 375                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 376                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 377                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 378                                 RESOURCE_COMPONENT_TYPE);
 379                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 380                                 getAllCategoriesRest.getErrorCode().intValue());
 381                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 382                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 383
 384                 DbUtils.deleteFromEsDbByPattern("_all");
 385                 createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 386                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 387                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 388                                 createSubCategoryRest.getErrorCode().intValue());
 389                 getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
 390                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 391                                 getAllCategoriesRest.getErrorCode().intValue());
 392                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 393                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 394                 // Audit validation
 395                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, productCategoryDefinition,
 396                                 productSubCategoryDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED,
 397                                 AUDIT_PRODUCT_TYPE);
 398         }
 399
 400         @Test
 401         public void createResourceSubCategoryByNonAdminUser() throws Exception {
 402                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 403                                 resourceCategoryDefinition, sdncTesterUserDetails, RESOURCE_COMPONENT_TYPE);
 404                 assertEquals("Check response code after create Sub category", STATUS_CODE_RESTRICTED_OPERATION,
 405                                 createSubCategoryRest.getErrorCode().intValue());
 406                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 407                                 RESOURCE_COMPONENT_TYPE);
 408                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 409                                 getAllCategoriesRest.getErrorCode().intValue());
 410                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 411                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 412                 // Audit validation
 413                 resourceCategoryDefinition.setName(resourceCategoryDefinition.getUniqueId());
 414                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 415                                 resourceSubCategoryDefinition, sdncTesterUserDetails, ActionStatus.RESTRICTED_OPERATION,
 416                                 STATUS_CODE_RESTRICTED_OPERATION, AUDIT_RESOURCE_TYPE);
 417         }
 418
 419         @Test
 420         public void createResourceSubCategoryByProducStrategistUser() throws Exception {
 421                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 422                                 resourceCategoryDefinition, sdncProductStrategistUserDetails, RESOURCE_COMPONENT_TYPE);
 423                 assertEquals("Check response code after create Sub category", STATUS_CODE_RESTRICTED_OPERATION,
 424                                 createSubCategoryRest.getErrorCode().intValue());
 425                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 426                                 RESOURCE_COMPONENT_TYPE);
 427                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 428                                 getAllCategoriesRest.getErrorCode().intValue());
 429                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 430                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 431                 // Audit validation
 432                 resourceCategoryDefinition.setName(resourceCategoryDefinition.getUniqueId());
 433                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 434                                 resourceSubCategoryDefinition, sdncProductStrategistUserDetails, ActionStatus.RESTRICTED_OPERATION,
 435                                 STATUS_CODE_RESTRICTED_OPERATION, AUDIT_RESOURCE_TYPE);
 436         }
 437
 438         @Test
 439         public void createProductSubCategoryByNonProducStrategistUser() throws Exception {
 440                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 441                                 productCategoryDefinition, sdncDesignerUserDetails, PRODUCT_COMPONENT_TYPE);
 442                 assertEquals("Check response code after create Sub category", STATUS_CODE_RESTRICTED_OPERATION,
 443                                 createSubCategoryRest.getErrorCode().intValue());
 444                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 445                                 PRODUCT_COMPONENT_TYPE);
 446                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 447                                 getAllCategoriesRest.getErrorCode().intValue());
 448                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 449                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 450                 // Audit validation
 451                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 452                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, productCategoryDefinition,
 453                                 productSubCategoryDefinition, sdncDesignerUserDetails, ActionStatus.RESTRICTED_OPERATION,
 454                                 STATUS_CODE_RESTRICTED_OPERATION, AUDIT_PRODUCT_TYPE);
 455         }
 456
 457         @Test
 458         public void createProductSubCategoryByAdminUser() throws Exception {
 459                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 460                                 productCategoryDefinition, sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
 461                 assertEquals("Check response code after create Sub category", STATUS_CODE_RESTRICTED_OPERATION,
 462                                 createSubCategoryRest.getErrorCode().intValue());
 463                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 464                                 PRODUCT_COMPONENT_TYPE);
 465                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 466                                 getAllCategoriesRest.getErrorCode().intValue());
 467                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 468                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 469                 // Audit validation
 470                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 471                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, productCategoryDefinition,
 472                                 productSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.RESTRICTED_OPERATION,
 473                                 STATUS_CODE_RESTRICTED_OPERATION, AUDIT_PRODUCT_TYPE);
 474         }
 475
 476         // @Ignore("DE176245")
 477         @Test
 478         public void createResourceSubCategoryForNonExistingComponentType() throws Exception {
 479                 String nonSupportedComponentType = "NonExistingComponentType"; // instead
 480                                                                                                                                                 // resource/product
 481                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 482                                 resourceCategoryDefinition, sdncAdminUserDetails, nonSupportedComponentType);
 483                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 484                                 createSubCategoryRest.getErrorCode().intValue());
 485                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 486                                 RESOURCE_COMPONENT_TYPE);
 487                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 488                                 getAllCategoriesRest.getErrorCode().intValue());
 489                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 490                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 491                 // Audit validation
 492                 resourceCategoryDefinition.setName(resourceCategoryDefinition.getUniqueId());
 493                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 494                                 resourceSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.INVALID_CONTENT,
 495                                 STATUS_CODE_INVALID_CONTENT, nonSupportedComponentType);
 496         }
 497
 498         // @Ignore("DE176245")
 499         @Test
 500         public void createProductSubCategoryForNonExistingComponentType() throws Exception {
 501                 String nonSupportedComponentType = "NonExistingComponentType"; // instead
 502                                                                                                                                                 // resource/product
 503                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 504                                 productCategoryDefinition, sdncProductStrategistUserDetails, nonSupportedComponentType);
 505                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 506                                 createSubCategoryRest.getErrorCode().intValue());
 507                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 508                                 PRODUCT_COMPONENT_TYPE);
 509                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 510                                 getAllCategoriesRest.getErrorCode().intValue());
 511                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 512                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 513                 // Audit validation
 514                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 515                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, productCategoryDefinition,
 516                                 productSubCategoryDefinition, sdncProductStrategistUserDetails, ActionStatus.INVALID_CONTENT,
 517                                 STATUS_CODE_INVALID_CONTENT, nonSupportedComponentType);
 518         }
 519
 520         @Test
 521         public void createServiceSubCategoryByAdmin() throws Exception {
 522                 // Service doesn't have sub-category
 523                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 524                                 resourceCategoryDefinition, sdncAdminUserDetails, SERVICE_COMPONENT_TYPE);
 525                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 526                                 createSubCategoryRest.getErrorCode().intValue());
 527                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 528                                 RESOURCE_COMPONENT_TYPE);
 529                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 530                                 getAllCategoriesRest.getErrorCode().intValue());
 531                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 532                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 533                 // Audit validation
 534                 resourceCategoryDefinition.setName(resourceCategoryDefinition.getUniqueId());
 535                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 536                                 resourceSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.INVALID_CONTENT,
 537                                 STATUS_CODE_INVALID_CONTENT, AUDIT_SERVICE_TYPE);
 538         }
 539
 540         @Test
 541         public void createServiceSubCategoryByProductStrategist() throws Exception {
 542                 // Service doesn't have sub-category
 543                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 544                                 productCategoryDefinition, sdncProductStrategistUserDetails, SERVICE_COMPONENT_TYPE);
 545                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 546                                 createSubCategoryRest.getErrorCode().intValue());
 547                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 548                                 PRODUCT_COMPONENT_TYPE);
 549                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 550                                 getAllCategoriesRest.getErrorCode().intValue());
 551                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 552                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition);
 553                 // Audit validation
 554                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 555                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, productCategoryDefinition,
 556                                 productSubCategoryDefinition, sdncProductStrategistUserDetails, ActionStatus.INVALID_CONTENT,
 557                                 STATUS_CODE_INVALID_CONTENT, AUDIT_SERVICE_TYPE);
 558         }
 559
 560         @Test
 561         public void createResourceSubCategoryForNonExistingCategory() throws Exception {
 562                 resourceCategoryDefinition100.setUniqueId(resourceCategoryDefinition100.getName());
 563                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 564                                 resourceCategoryDefinition100, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 565                 assertEquals("Check response code after create Sub category", STATUS_CODE_NOT_FOUND,
 566                                 createSubCategoryRest.getErrorCode().intValue());
 567                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition100,
 568                                 resourceSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.COMPONENT_CATEGORY_NOT_FOUND,
 569                                 STATUS_CODE_NOT_FOUND, AUDIT_RESOURCE_TYPE, RESOURCE_COMPONENT_TYPE, CATEGORY, "");
 570
 571                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 572                                 RESOURCE_COMPONENT_TYPE);
 573                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 574                                 getAllCategoriesRest.getErrorCode().intValue());
 575                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 576                                 resourceCategoryDefinition100.getUniqueId(), resourceSubCategoryDefinition);
 577         }
 578
 579         @Test
 580         public void createProductSubCategoryForNonExistingCategory() throws Exception {
 581                 productCategoryDefinition200.setUniqueId(productCategoryDefinition200.getName());
 582                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 583                                 productCategoryDefinition200, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 584                 assertEquals("Check response code after create Sub category", STATUS_CODE_NOT_FOUND,
 585                                 createSubCategoryRest.getErrorCode().intValue());
 586                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 587                                 PRODUCT_COMPONENT_TYPE);
 588                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 589                                 getAllCategoriesRest.getErrorCode().intValue());
 590                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
 591                                 productCategoryDefinition200.getUniqueId(), productSubCategoryDefinition);
 592                 // Audit validation // need to change ActionStatus
 593                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, productCategoryDefinition200,
 594                                 productSubCategoryDefinition, sdncProductStrategistUserDetails,
 595                                 ActionStatus.COMPONENT_CATEGORY_NOT_FOUND, STATUS_CODE_NOT_FOUND, AUDIT_PRODUCT_TYPE,
 596                                 PRODUCT_COMPONENT_TYPE, CATEGORY, "");
 597         }
 598
 599         // pass
 600         @Test
 601         public void subCategoryAllowedcharacters_01() throws Exception {
 602                 resourceSubCategoryDefinition.setName("1234AbcdE-");
 603                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 604                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 605                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 606                                 createSubCategoryRest.getErrorCode().intValue());
 607                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 608                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 609                                 RESOURCE_COMPONENT_TYPE);
 610                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 611                                 getAllCategoriesRest.getErrorCode().intValue());
 612                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 613                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition); // also
 614                                                                                                                                                                                         // set
 615                                                                                                                                                                                         // catalog
 616                                                                                                                                                                                         // uniqeId
 617                 // Audit validation
 618                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 619                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 620         }
 621
 622         // pass
 623         @Test
 624         public void subCategoryAllowedcharacters_02() throws Exception {
 625                 resourceSubCategoryDefinition.setName("1234AbcdE+");
 626                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 627                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 628                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 629                                 createSubCategoryRest.getErrorCode().intValue());
 630                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 631
 632                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 633                                 RESOURCE_COMPONENT_TYPE);
 634                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 635                                 getAllCategoriesRest.getErrorCode().intValue());
 636                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 637                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 638                 // Audit validation
 639                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 640                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 641         }
 642
 643         @Test
 644         public void subCategoryAllowedcharacters_03() throws Exception {
 645                 resourceSubCategoryDefinition.setName("1234AbcdE&");
 646                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 647                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 648                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 649                                 createSubCategoryRest.getErrorCode().intValue());
 650                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 651
 652                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 653                                 RESOURCE_COMPONENT_TYPE);
 654                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 655                                 getAllCategoriesRest.getErrorCode().intValue());
 656                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 657                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 658                 // Audit validation
 659                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 660                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 661         }
 662
 663         @Test
 664         public void subCategoryAllowedcharacters_04() throws Exception {
 665                 resourceSubCategoryDefinition.setName("1234AbcdE.");
 666                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 667                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 668                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 669                                 createSubCategoryRest.getErrorCode().intValue());
 670                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 671                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 672                                 RESOURCE_COMPONENT_TYPE);
 673                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 674                                 getAllCategoriesRest.getErrorCode().intValue());
 675                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 676                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 677                 // Audit validation
 678                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 679                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 680         }
 681
 682         @Test
 683         public void subCategoryAllowedcharacters_05() throws Exception {
 684                 resourceSubCategoryDefinition.setName("1234AbcdE'");
 685                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 686                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 687                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 688                                 createSubCategoryRest.getErrorCode().intValue());
 689                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 690                                 RESOURCE_COMPONENT_TYPE);
 691                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 692
 693                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 694                                 getAllCategoriesRest.getErrorCode().intValue());
 695                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 696                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 697                 // Audit validation
 698                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 699                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 700         }
 701
 702         @Test
 703         public void subCategoryAllowedcharacters_06() throws Exception {
 704                 resourceSubCategoryDefinition.setName("1234AbcdE=");
 705                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 706                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 707                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 708                                 createSubCategoryRest.getErrorCode().intValue());
 709                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 710
 711                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 712                                 RESOURCE_COMPONENT_TYPE);
 713                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 714                                 getAllCategoriesRest.getErrorCode().intValue());
 715                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 716                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 717                 // Audit validation
 718                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 719                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 720         }
 721
 722         @Test
 723         public void subCategoryAllowedcharacters_07() throws Exception {
 724                 resourceSubCategoryDefinition.setName("1234AbcdE:");
 725                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 726                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 727                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 728                                 createSubCategoryRest.getErrorCode().intValue());
 729                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 730
 731                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 732                                 RESOURCE_COMPONENT_TYPE);
 733                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 734                                 getAllCategoriesRest.getErrorCode().intValue());
 735                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 736                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 737                 // Audit validation
 738                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 739                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 740         }
 741
 742         @Test
 743         public void subCategoryAllowedcharacters_08() throws Exception {
 744                 resourceSubCategoryDefinition.setName("1234AbcdE@");
 745                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 746                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 747                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 748                                 createSubCategoryRest.getErrorCode().intValue());
 749                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 750
 751                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 752                                 RESOURCE_COMPONENT_TYPE);
 753                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 754                                 getAllCategoriesRest.getErrorCode().intValue());
 755                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 756                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 757                 // Audit validation
 758                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 759                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 760         }
 761
 762         @Test
 763         public void subCategoryAllowedcharacters_09() throws Exception {
 764                 resourceSubCategoryDefinition.setName("1234AbcdE_");
 765                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 766                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 767                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 768                                 createSubCategoryRest.getErrorCode().intValue());
 769                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 770
 771                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 772                                 RESOURCE_COMPONENT_TYPE);
 773                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 774                                 getAllCategoriesRest.getErrorCode().intValue());
 775                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 776                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 777                 // Audit validation
 778                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 779                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 780         }
 781
 782         @Test
 783         public void subCategoryAllowedcharacters_10() throws Exception {
 784                 resourceSubCategoryDefinition.setName("1234AbcdE#");
 785                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 786                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 787                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 788                                 createSubCategoryRest.getErrorCode().intValue());
 789                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 790
 791                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 792                                 RESOURCE_COMPONENT_TYPE);
 793                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 794                                 getAllCategoriesRest.getErrorCode().intValue());
 795                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 796                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 797                 // Audit validation
 798                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 799                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 800         }
 801
 802         @Test
 803         public void subCategoryAllowedcharacters_11() throws Exception {
 804                 resourceSubCategoryDefinition.setName("1234AbcdE d");
 805                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 806                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 807                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 808                                 createSubCategoryRest.getErrorCode().intValue());
 809                 resourceSubCategoryDefinition.setName("1234AbcdE D");
 810                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 811
 812                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 813                                 RESOURCE_COMPONENT_TYPE);
 814                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 815                                 getAllCategoriesRest.getErrorCode().intValue());
 816                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 817                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 818                 // Audit validation
 819                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 820                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 821         }
 822
 823         @Test
 824         public void subCategoryAllowedcharacters_12() throws Exception {
 825                 resourceSubCategoryDefinition.setName("1234AbcdE   &_=+.-'#:@ d");
 826                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 827                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 828                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 829                                 createSubCategoryRest.getErrorCode().intValue());
 830                 resourceSubCategoryDefinition.setName("1234AbcdE &_=+.-'#:@ D");
 831                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 832
 833                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 834                                 RESOURCE_COMPONENT_TYPE);
 835                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 836                                 getAllCategoriesRest.getErrorCode().intValue());
 837                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 838                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 839                 // Audit validation
 840                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 841                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 842         }
 843
 844         @Test
 845         public void subCategoryRemoveSpaceFromBeginning() throws Exception {
 846                 resourceSubCategoryDefinition.setName("  Category01");
 847                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 848                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 849                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 850                                 createSubCategoryRest.getErrorCode().intValue());
 851                 resourceSubCategoryDefinition.setName("Category01");
 852                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 853
 854                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 855                                 RESOURCE_COMPONENT_TYPE);
 856                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 857                                 getAllCategoriesRest.getErrorCode().intValue());
 858                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 859                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 860                 // Audit validation
 861                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 862                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 863         }
 864
 865         @Test
 866         public void subCategoryRemoveSpaceFromEnd() throws Exception {
 867                 resourceSubCategoryDefinition.setName("Category01    ");
 868                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 869                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 870                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 871                                 createSubCategoryRest.getErrorCode().intValue());
 872                 resourceSubCategoryDefinition.setName("Category01");
 873                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 874
 875                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 876                                 RESOURCE_COMPONENT_TYPE);
 877                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 878                                 getAllCategoriesRest.getErrorCode().intValue());
 879                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 880                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 881                 // Audit validation
 882                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 883                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 884         }
 885
 886         @Test
 887         public void subCategoryRemoveExtraSpace() throws Exception {
 888                 resourceSubCategoryDefinition.setName("Category    02");
 889                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 890                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 891                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 892                                 createSubCategoryRest.getErrorCode().intValue());
 893                 resourceSubCategoryDefinition.setName("Category 02");
 894                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 895
 896                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 897                                 RESOURCE_COMPONENT_TYPE);
 898                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 899                                 getAllCategoriesRest.getErrorCode().intValue());
 900                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 901                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 902                 // Audit validation
 903                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 904                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 905         }
 906
 907         @Test
 908         public void subCategoryRemoveExtraAmpersand() throws Exception {
 909                 resourceSubCategoryDefinition.setName("Category&& &02");
 910                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 911                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 912                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 913                                 createSubCategoryRest.getErrorCode().intValue());
 914                 resourceSubCategoryDefinition.setName("Category& &02");
 915                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 916
 917                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 918                                 RESOURCE_COMPONENT_TYPE);
 919                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 920                                 getAllCategoriesRest.getErrorCode().intValue());
 921                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 922                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 923                 // Audit validation
 924                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 925                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 926         }
 927
 928         @Test
 929         public void subCategoryRemoveExtraDash() throws Exception {
 930                 resourceSubCategoryDefinition.setName("CategorY-- --02");
 931                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 932                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 933                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 934                                 createSubCategoryRest.getErrorCode().intValue());
 935                 resourceSubCategoryDefinition.setName("CategorY- -02");
 936                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 937
 938                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 939                                 RESOURCE_COMPONENT_TYPE);
 940                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 941                                 getAllCategoriesRest.getErrorCode().intValue());
 942                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 943                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 944                 // Audit validation
 945                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 946                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 947         }
 948
 949         @Test
 950         public void subCategoryRemoveExtraPlus() throws Exception {
 951                 resourceSubCategoryDefinition.setName("CateGory++++ +02");
 952                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 953                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 954                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 955                                 createSubCategoryRest.getErrorCode().intValue());
 956                 resourceSubCategoryDefinition.setName("CateGory+ +02");
 957                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 958
 959                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 960                                 RESOURCE_COMPONENT_TYPE);
 961                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 962                                 getAllCategoriesRest.getErrorCode().intValue());
 963                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 964                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 965                 // Audit validation
 966                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 967                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 968         }
 969
 970         @Test
 971         public void subCategoryRemoveExtraPeriod() throws Exception {
 972                 resourceSubCategoryDefinition.setName("Category.... .02");
 973                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 974                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 975                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 976                                 createSubCategoryRest.getErrorCode().intValue());
 977                 resourceSubCategoryDefinition.setName("Category. .02");
 978                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
 979
 980                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 981                                 RESOURCE_COMPONENT_TYPE);
 982                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 983                                 getAllCategoriesRest.getErrorCode().intValue());
 984                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
 985                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
 986                 // Audit validation
 987                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
 988                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
 989         }
 990
 991         @Test
 992         public void subCategoryRemoveExtraApostrophe() throws Exception {
 993                 resourceSubCategoryDefinition.setName("CaTegory''' '02");
 994                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
 995                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
 996                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
 997                                 createSubCategoryRest.getErrorCode().intValue());
 998                 resourceSubCategoryDefinition.setName("CaTegory' '02");
 999                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1000
1001                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1002                                 RESOURCE_COMPONENT_TYPE);
1003                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1004                                 getAllCategoriesRest.getErrorCode().intValue());
1005                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1006                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1007                 // Audit validation
1008                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1009                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1010         }
1011
1012         @Test
1013         public void subCategoryRemoveExtraHashtag() throws Exception {
1014                 resourceSubCategoryDefinition.setName("Category### #02");
1015                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1016                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1017                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1018                                 createSubCategoryRest.getErrorCode().intValue());
1019                 resourceSubCategoryDefinition.setName("Category# #02");
1020                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1021
1022                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1023                                 RESOURCE_COMPONENT_TYPE);
1024                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1025                                 getAllCategoriesRest.getErrorCode().intValue());
1026                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1027                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1028                 // Audit validation
1029                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1030                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1031         }
1032
1033         @Test
1034         public void subCategoryRemoveExtrEequal() throws Exception {
1035                 resourceSubCategoryDefinition.setName("Category=== =02");
1036                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1037                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1038                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1039                                 createSubCategoryRest.getErrorCode().intValue());
1040                 resourceSubCategoryDefinition.setName("Category= =02");
1041                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1042
1043                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1044                                 RESOURCE_COMPONENT_TYPE);
1045                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1046                                 getAllCategoriesRest.getErrorCode().intValue());
1047                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1048                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1049                 // Audit validation
1050                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1051                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1052         }
1053
1054         @Test
1055         public void subCategoryRemoveExtrColon() throws Exception {
1056                 resourceSubCategoryDefinition.setName("Category::: :02");
1057                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1058                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1059                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1060                                 createSubCategoryRest.getErrorCode().intValue());
1061                 resourceSubCategoryDefinition.setName("Category: :02");
1062                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1063
1064                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1065                                 RESOURCE_COMPONENT_TYPE);
1066                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1067                                 getAllCategoriesRest.getErrorCode().intValue());
1068                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1069                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1070                 // Audit validation
1071                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1072                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1073         }
1074
1075         @Test
1076         public void subCategoryRemoveExtrAt() throws Exception {
1077                 resourceSubCategoryDefinition.setName("Category@@@ @a2");
1078                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1079                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1080                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1081                                 createSubCategoryRest.getErrorCode().intValue());
1082                 resourceSubCategoryDefinition.setName("Category@ @a2");
1083                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1084
1085                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1086                                 RESOURCE_COMPONENT_TYPE);
1087                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1088                                 getAllCategoriesRest.getErrorCode().intValue());
1089                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1090                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1091                 // Audit validation
1092                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1093                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1094         }
1095
1096         @Test
1097         public void subCategoryRemoveExtraUnderscore() throws Exception {
1098                 resourceSubCategoryDefinition.setName("Category___ _22");
1099                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1100                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1101                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1102                                 createSubCategoryRest.getErrorCode().intValue());
1103                 resourceSubCategoryDefinition.setName("Category_ _22");
1104                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1105
1106                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1107                                 RESOURCE_COMPONENT_TYPE);
1108                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1109                                 getAllCategoriesRest.getErrorCode().intValue());
1110                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1111                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1112                 // Audit validation
1113                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1114                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1115         }
1116
1117         @Test
1118         public void subCategoryFirstWordStartWithNumber() throws Exception {
1119                 resourceSubCategoryDefinition.setName("1Category one");
1120                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1121                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1122                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1123                                 createSubCategoryRest.getErrorCode().intValue());
1124                 resourceSubCategoryDefinition.setName("1Category One");
1125                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1126
1127                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1128                                 RESOURCE_COMPONENT_TYPE);
1129                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1130                                 getAllCategoriesRest.getErrorCode().intValue());
1131                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1132                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1133                 // Audit validation
1134                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1135                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1136         }
1137
1138         // Bug
1139         // Desc=<ACTION = "AddSubCategory" MODIFIER = "Jimmy Hendrix(jh0003)"
1140         // CATEGORY_NAME = "Category1" SUB_CATEGORY_NAME = "&AbcD123" GROUPING_NAME
1141         // = "" RESOURCE_TYPE = "Resource" STATUS = "400" DESC = "SVC4556: Error:
1142         // Invalid Resource sub-category name format.">
1143         // DESC=SVC4556: Error: InvalidResourcesub-categorynameformat.,
1144         // @Ignore
1145         @Test
1146         public void subCategoryFirstWordStartWithNonAlphaNumeric() throws Exception {
1147                 // The first word must start with an alpha-numeric character [a-Z A..Z,
1148                 // 0..9]
1149                 char invalidChars[] = { '&', '-', '+', '.', '\'', '#', '=', ':', '@', '_' };
1150                 for (int i = 0; i < invalidChars.length; i++) {
1151                         DbUtils.deleteFromEsDbByPattern("_all");
1152                         resourceSubCategoryDefinition.setName(invalidChars[i] + "AbcD123");
1153                         RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1154                                         resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1155                         assertEquals("Check response code after create Category", STATUS_CODE_INVALID_CONTENT,
1156                                         createSubCategoryRest.getErrorCode().intValue());
1157                         RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1158                                         RESOURCE_COMPONENT_TYPE);
1159                         assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1160                                         getAllCategoriesRest.getErrorCode().intValue());
1161                         CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1162                                         resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1163                         // Audit validation
1164                         AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1165                                         resourceSubCategoryDefinition, sdncAdminUserDetails,
1166                                         ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT, STATUS_CODE_INVALID_CONTENT,
1167                                         AUDIT_RESOURCE_TYPE, AUDIT_RESOURCE_TYPE, SUB_CATEGORY);
1168
1169                 }
1170         }
1171
1172         @Test
1173         public void subCategoryReplaceAndWithAmpersand_01() throws Exception {
1174                 resourceSubCategoryDefinition.setName("At and T");
1175                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1176                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1177                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1178                                 createSubCategoryRest.getErrorCode().intValue());
1179                 resourceSubCategoryDefinition.setName("At & T");
1180                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1181
1182                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1183                                 RESOURCE_COMPONENT_TYPE);
1184                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1185                                 getAllCategoriesRest.getErrorCode().intValue());
1186                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1187                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1188                 // Audit validation
1189                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1190                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1191         }
1192
1193         @Test
1194         public void subCategoryReplaceAndWithAmpersand_02() throws Exception {
1195                 resourceSubCategoryDefinition.setName("At and t");
1196                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1197                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1198                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1199                                 createSubCategoryRest.getErrorCode().intValue());
1200                 resourceSubCategoryDefinition.setName("At & T");
1201                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1202
1203                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1204                                 RESOURCE_COMPONENT_TYPE);
1205                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1206                                 getAllCategoriesRest.getErrorCode().intValue());
1207                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1208                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1209                 // Audit validation
1210                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1211                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1212         }
1213
1214         @Test
1215         public void subCategoryReplaceAndWithAmpersand_03() throws Exception {
1216                 resourceSubCategoryDefinition.setName("Atand T");
1217                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1218                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1219                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1220                                 createSubCategoryRest.getErrorCode().intValue());
1221                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1222
1223                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1224                                 RESOURCE_COMPONENT_TYPE);
1225                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1226                                 getAllCategoriesRest.getErrorCode().intValue());
1227                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1228                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1229                 // Audit validation
1230                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1231                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1232         }
1233
1234         @Test
1235         public void subCategoryReplaceAndWithAmpersand_04() throws Exception {
1236                 resourceSubCategoryDefinition.setName("At andT");
1237                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1238                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1239                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1240                                 createSubCategoryRest.getErrorCode().intValue());
1241                 resourceSubCategoryDefinition.setName("At AndT");
1242                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1243
1244                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1245                                 RESOURCE_COMPONENT_TYPE);
1246                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1247                                 getAllCategoriesRest.getErrorCode().intValue());
1248                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1249                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1250                 // Audit validation
1251                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1252                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1253         }
1254
1255         @Test
1256         public void subCategoryReplaceAndWithAmpersand_05() throws Exception {
1257                 resourceSubCategoryDefinition.setName(" and AttT");
1258                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1259                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1260                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1261                                 createSubCategoryRest.getErrorCode().intValue());
1262                 resourceSubCategoryDefinition.setName("And AttT");
1263                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1264
1265                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1266                                 RESOURCE_COMPONENT_TYPE);
1267                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1268                                 getAllCategoriesRest.getErrorCode().intValue());
1269                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1270                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1271                 // Audit validation
1272                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1273                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1274         }
1275
1276         @Test
1277         public void subCategoryReplaceAndWithAmpersand_06() throws Exception {
1278                 resourceSubCategoryDefinition.setName("AttT and ");
1279                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1280                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1281                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1282                                 createSubCategoryRest.getErrorCode().intValue());
1283                 resourceSubCategoryDefinition.setName("AttT And");
1284                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1285
1286                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1287                                 RESOURCE_COMPONENT_TYPE);
1288                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1289                                 getAllCategoriesRest.getErrorCode().intValue());
1290                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1291                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1292                 // Audit validation
1293                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1294                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1295         }
1296
1297         @Test
1298         public void subCategoryReplaceAndWithAmpersand_07() throws Exception {
1299                 resourceSubCategoryDefinition.setName(" and a");
1300                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1301                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1302                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1303                                 createSubCategoryRest.getErrorCode().intValue());
1304                 resourceSubCategoryDefinition.setName("And a");
1305                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1306
1307                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1308                                 RESOURCE_COMPONENT_TYPE);
1309                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1310                                 getAllCategoriesRest.getErrorCode().intValue());
1311                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1312                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1313                 // Audit validation
1314                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1315                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1316         }
1317
1318         @Test
1319         public void subCategoryNameValidationMaxLength() throws Exception {
1320                 resourceSubCategoryDefinition.setName("AsdfghjQ234567890@#.&:+-_");
1321                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1322                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1323                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1324                                 createSubCategoryRest.getErrorCode().intValue());
1325                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1326
1327                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1328                                 RESOURCE_COMPONENT_TYPE);
1329                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1330                                 getAllCategoriesRest.getErrorCode().intValue());
1331                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1332                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1333                 // Audit validation
1334                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1335                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1336         }
1337
1338         @Test
1339         public void subCategoryNameValidationMaxLengthAfterNormalization() throws Exception {
1340                 resourceSubCategoryDefinition.setName("  A jQ234 @@@___ +++ At and T and and ");
1341                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1342                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1343                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1344                                 createSubCategoryRest.getErrorCode().intValue());
1345                 resourceSubCategoryDefinition.setName("A JQ234 @_ + At & T & And");
1346                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1347
1348                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1349                                 RESOURCE_COMPONENT_TYPE);
1350                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1351                                 getAllCategoriesRest.getErrorCode().intValue());
1352                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1353                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1354                 // Audit validation
1355                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1356                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1357         }
1358
1359         // bug :
1360         // Desc=<ACTION = "AddSubCategory" MODIFIER = "Jimmy Hendrix(jh0003)"
1361         // CATEGORY_NAME = "Category1" SUB_CATEGORY_NAME = " AbdfghBCVa jQ234 @@___
1362         // +++ At and T " GROUPING_NAME = "" RESOURCE_TYPE = "Resource" STATUS =
1363         // "400" DESC = "SVC4555: Error: Invalid Resource sub-category name
1364         // length.">
1365         @Test
1366         public void subCategoryNameValidationExceedMaxLengthAfterNormalization() throws Exception {
1367                 resourceSubCategoryDefinition.setName("  AbdfghBCVa jQ234 @@___ +++ At and T   ");
1368                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1369                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1370                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
1371                                 createSubCategoryRest.getErrorCode().intValue());
1372                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1373                                 RESOURCE_COMPONENT_TYPE);
1374                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1375                                 getAllCategoriesRest.getErrorCode().intValue());
1376                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1377                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1378                 // Audit validation
1379                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1380                                 resourceSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH,
1381                                 STATUS_CODE_INVALID_CONTENT, AUDIT_RESOURCE_TYPE, AUDIT_RESOURCE_TYPE, SUB_CATEGORY);
1382         }
1383
1384         @Test
1385         public void subCategoryNameValidationMinLengthAfterNormalization() throws Exception {
1386                 resourceSubCategoryDefinition.setName("  AT&&&&&&&&&T   ");
1387                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1388                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1389                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1390                                 createSubCategoryRest.getErrorCode().intValue());
1391                 resourceSubCategoryDefinition.setName("AT&T");
1392                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1393
1394                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1395                                 RESOURCE_COMPONENT_TYPE);
1396                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1397                                 getAllCategoriesRest.getErrorCode().intValue());
1398                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1399                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1400                 // Audit validation
1401                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1402                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1403         }
1404
1405         // bug
1406         // Desc=<ACTION = "AddSubCategory" MODIFIER = "Jimmy Hendrix(jh0003)"
1407         // CATEGORY_NAME = "Category1" SUB_CATEGORY_NAME = " A and T " GROUPING_NAME
1408         // = "" RESOURCE_TYPE = "Resource" STATUS = "400" DESC = "SVC4555: Error:
1409         // Invalid Resource sub-category name length.">
1410         @Test
1411         public void subCategoryNameValidationLessThanMinLengthAfterNormalization() throws Exception {
1412                 resourceSubCategoryDefinition.setName("  A&&&T   ");
1413                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1414                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1415                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
1416                                 createSubCategoryRest.getErrorCode().intValue());
1417                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1418                                 RESOURCE_COMPONENT_TYPE);
1419                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1420                                 getAllCategoriesRest.getErrorCode().intValue());
1421                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1422                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1423                 // Audit validation
1424                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1425                                 resourceSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH,
1426                                 STATUS_CODE_INVALID_CONTENT, AUDIT_RESOURCE_TYPE, AUDIT_RESOURCE_TYPE, SUB_CATEGORY);
1427         }
1428
1429         @Test
1430         public void subCategoryNameIsEmpty() throws Exception {
1431                 resourceSubCategoryDefinition.setName("");
1432                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1433                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1434                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
1435                                 createSubCategoryRest.getErrorCode().intValue());
1436                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1437                                 RESOURCE_COMPONENT_TYPE);
1438                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1439                                 getAllCategoriesRest.getErrorCode().intValue());
1440                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1441                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1442                 // Audit validation
1443                 AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1444                                 resourceSubCategoryDefinition, sdncAdminUserDetails, ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT,
1445                                 STATUS_CODE_INVALID_CONTENT, AUDIT_RESOURCE_TYPE, AUDIT_RESOURCE_TYPE, SUB_CATEGORY);
1446         }
1447
1448         // bug
1449         // Desc=<ACTION = "AddSubCategory" MODIFIER = "Jimmy Hendrix(jh0003)"
1450         // CATEGORY_NAME = "Category1" SUB_CATEGORY_NAME = "AbcD123~" GROUPING_NAME
1451         // = "" RESOURCE_TYPE = "Resource" STATUS = "400" DESC = "SVC4556: Error:
1452         // Invalid Resource sub-category name format.">
1453         @Test
1454         public void subCategoryNameValidationInvalidCharacters() throws Exception {
1455                 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/',
1456                                 '|', '\\', ',' };
1457                 for (int i = 0; i < invalidChars.length; i++) {
1458                         DbUtils.deleteFromEsDbByPattern("_all");
1459                         resourceSubCategoryDefinition.setName("AbcD123" + invalidChars[i]);
1460                         RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1461                                         resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1462                         assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
1463                                         createSubCategoryRest.getErrorCode().intValue());
1464                         RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1465                                         RESOURCE_COMPONENT_TYPE);
1466                         assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1467                                         getAllCategoriesRest.getErrorCode().intValue());
1468                         CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1469                                         resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1470                         // Audit validation
1471                         AuditValidationUtils.subCategoryAuditFailure(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1472                                         resourceSubCategoryDefinition, sdncAdminUserDetails,
1473                                         ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT, STATUS_CODE_INVALID_CONTENT,
1474                                         AUDIT_RESOURCE_TYPE, AUDIT_RESOURCE_TYPE, SUB_CATEGORY);
1475                 }
1476         }
1477
1478         @Test
1479         public void subCategoryNameValidationFirstLetterOfKeyWordsCapitalized() throws Exception {
1480                 resourceSubCategoryDefinition.setName("beNNy shaY michEl");
1481                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1482                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1483                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1484                                 createSubCategoryRest.getErrorCode().intValue());
1485                 resourceSubCategoryDefinition.setName("BeNNy ShaY MichEl");
1486                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1487
1488                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1489                                 RESOURCE_COMPONENT_TYPE);
1490                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1491                                 getAllCategoriesRest.getErrorCode().intValue());
1492                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1493                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1494                 // Audit validation
1495                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1496                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1497         }
1498
1499         @Test
1500         public void subCategoryNameValidationConjunctions_01() throws Exception {
1501                 resourceSubCategoryDefinition.setName(" bank OF america  ");
1502                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1503                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1504                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1505                                 createSubCategoryRest.getErrorCode().intValue());
1506                 resourceSubCategoryDefinition.setName("Bank of America");
1507                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1508
1509                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1510                                 RESOURCE_COMPONENT_TYPE);
1511                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1512                                 getAllCategoriesRest.getErrorCode().intValue());
1513                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1514                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1515                 // Audit validation
1516                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1517                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1518         }
1519
1520         @Test
1521         public void subCategoryNameValidationConjunctions_02() throws Exception {
1522                 resourceSubCategoryDefinition.setName("THE america bank   ");
1523                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1524                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1525                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1526                                 createSubCategoryRest.getErrorCode().intValue());
1527                 resourceSubCategoryDefinition.setName("THE America Bank");
1528                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1529
1530                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1531                                 RESOURCE_COMPONENT_TYPE);
1532                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1533                                 getAllCategoriesRest.getErrorCode().intValue());
1534                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1535                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1536                 // Audit validation
1537                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1538                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1539         }
1540
1541         @Test
1542         public void subCategoryNameValidationConjunctions_03() throws Exception {
1543                 resourceSubCategoryDefinition.setName("   A bank OF america  ");
1544                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1545                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1546                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1547                                 createSubCategoryRest.getErrorCode().intValue());
1548                 resourceSubCategoryDefinition.setName("A Bank of America");
1549                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1550
1551                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1552                                 RESOURCE_COMPONENT_TYPE);
1553                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1554                                 getAllCategoriesRest.getErrorCode().intValue());
1555                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1556                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1557                 // Audit validation
1558                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1559                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1560         }
1561
1562         @Test
1563         public void subCategoryNameValidationConjunctions_04() throws Exception {
1564                 resourceSubCategoryDefinition.setName("  bank  america is A big ban  ");
1565                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1566                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1567                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1568                                 createSubCategoryRest.getErrorCode().intValue());
1569                 resourceSubCategoryDefinition.setName("Bank America Is a Big Ban");
1570                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1571
1572                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1573                                 RESOURCE_COMPONENT_TYPE);
1574                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1575                                 getAllCategoriesRest.getErrorCode().intValue());
1576                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1577                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1578                 // Audit validation
1579                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1580                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1581         }
1582
1583         @Test
1584         public void subCategoryNameValidationConjunctions_05() throws Exception {
1585                 resourceSubCategoryDefinition.setName(" aN apple comPany inC ");
1586                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1587                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1588                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1589                                 createSubCategoryRest.getErrorCode().intValue());
1590                 resourceSubCategoryDefinition.setName("AN Apple ComPany InC");
1591                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1592
1593                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1594                                 RESOURCE_COMPONENT_TYPE);
1595                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1596                                 getAllCategoriesRest.getErrorCode().intValue());
1597                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1598                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1599                 // Audit validation
1600                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1601                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1602         }
1603
1604         @Test
1605         public void subCategoryNameValidationConjunctions_06() throws Exception {
1606                 resourceSubCategoryDefinition.setName(" eat AN apple ANAN");
1607                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1608                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1609                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1610                                 createSubCategoryRest.getErrorCode().intValue());
1611                 resourceSubCategoryDefinition.setName("Eat an Apple ANAN");
1612                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1613
1614                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1615                                 RESOURCE_COMPONENT_TYPE);
1616                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1617                                 getAllCategoriesRest.getErrorCode().intValue());
1618                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1619                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1620                 // Audit validation
1621                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1622                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1623         }
1624
1625         @Test
1626         public void subCategoryNameValidationConjunctions_07() throws Exception {
1627                 resourceSubCategoryDefinition.setName(" united states OF americA ");
1628                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1629                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1630                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1631                                 createSubCategoryRest.getErrorCode().intValue());
1632                 resourceSubCategoryDefinition.setName("United States of AmericA");
1633                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1634
1635                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1636                                 RESOURCE_COMPONENT_TYPE);
1637                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1638                                 getAllCategoriesRest.getErrorCode().intValue());
1639                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1640                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1641                 // Audit validation
1642                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1643                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1644         }
1645
1646         @Test
1647         public void subCategoryNameValidationConjunctions_08() throws Exception {
1648                 resourceSubCategoryDefinition.setName(" oF united states OF amer ");
1649                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1650                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1651                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1652                                 createSubCategoryRest.getErrorCode().intValue());
1653                 resourceSubCategoryDefinition.setName("OF United States of Amer");
1654                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1655
1656                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1657                                 RESOURCE_COMPONENT_TYPE);
1658                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1659                                 getAllCategoriesRest.getErrorCode().intValue());
1660                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1661                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1662                 // Audit validation
1663                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1664                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1665         }
1666
1667         @Test
1668         public void subCategoryNameValidationConjunctions_09() throws Exception {
1669                 resourceSubCategoryDefinition.setName(" to Apple TO at&T TOO ");
1670                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1671                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1672                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1673                                 createSubCategoryRest.getErrorCode().intValue());
1674                 resourceSubCategoryDefinition.setName("To Apple to At&T TOO");
1675                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1676
1677                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1678                                 RESOURCE_COMPONENT_TYPE);
1679                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1680                                 getAllCategoriesRest.getErrorCode().intValue());
1681                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1682                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1683                 // Audit validation
1684                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1685                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1686         }
1687
1688         @Test
1689         public void subCategoryNameValidationConjunctions_10() throws Exception {
1690                 resourceSubCategoryDefinition.setName(" eat apple AS you liiikeas ");
1691                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1692                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1693                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1694                                 createSubCategoryRest.getErrorCode().intValue());
1695                 resourceSubCategoryDefinition.setName("Eat Apple as You Liiikeas");
1696                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1697
1698                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1699                                 RESOURCE_COMPONENT_TYPE);
1700                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1701                                 getAllCategoriesRest.getErrorCode().intValue());
1702                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1703                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1704                 // Audit validation
1705                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1706                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1707         }
1708
1709         @Test
1710         public void subCategoryNameValidationConjunctions_11() throws Exception {
1711                 resourceSubCategoryDefinition.setName(" as you may want ");
1712                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1713                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1714                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1715                                 createSubCategoryRest.getErrorCode().intValue());
1716                 resourceSubCategoryDefinition.setName("As You May Want");
1717                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1718
1719                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1720                                 RESOURCE_COMPONENT_TYPE);
1721                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1722                                 getAllCategoriesRest.getErrorCode().intValue());
1723                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1724                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1725                 // Audit validation
1726                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1727                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1728         }
1729
1730         @Test
1731         public void subCategoryNameValidationConjunctions_12() throws Exception {
1732                 resourceSubCategoryDefinition.setName(" the bank OF america ");
1733                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1734                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1735                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1736                                 createSubCategoryRest.getErrorCode().intValue());
1737                 resourceSubCategoryDefinition.setName("The Bank of America");
1738                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1739
1740                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1741                                 RESOURCE_COMPONENT_TYPE);
1742                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1743                                 getAllCategoriesRest.getErrorCode().intValue());
1744                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1745                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1746                 // Audit validation
1747                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1748                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1749         }
1750
1751         @Test
1752         public void subCategoryNameValidationConjunctions_13() throws Exception {
1753                 resourceSubCategoryDefinition.setName("  To tel-toto ");
1754                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1755                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1756                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1757                                 createSubCategoryRest.getErrorCode().intValue());
1758                 resourceSubCategoryDefinition.setName("To Tel-toto");
1759                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1760
1761                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1762                                 RESOURCE_COMPONENT_TYPE);
1763                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1764                                 getAllCategoriesRest.getErrorCode().intValue());
1765                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1766                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1767                 // Audit validation
1768                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1769                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1770         }
1771
1772         @Test
1773         public void subCategoryNameValidationConjunctions_14() throws Exception {
1774                 resourceSubCategoryDefinition.setName("   tel-aviv To   la ");
1775                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1776                                 resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1777                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1778                                 createSubCategoryRest.getErrorCode().intValue());
1779                 resourceSubCategoryDefinition.setName("Tel-aviv to La");
1780                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, resourceSubCategoryDefinition);
1781
1782                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1783                                 RESOURCE_COMPONENT_TYPE);
1784                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1785                                 getAllCategoriesRest.getErrorCode().intValue());
1786                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1787                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1788                 // Audit validation
1789                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, resourceCategoryDefinition,
1790                                 resourceSubCategoryDefinition, sdncAdminUserDetails, STATUS_CODE_CREATED, AUDIT_RESOURCE_TYPE);
1791         }
1792
1793         @Test
1794         public void createSubCategoryHttpCspUserIdHeaderIsMissing() throws Exception {
1795                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategoryHttpCspAtuUidIsMissing(
1796                                 resourceSubCategoryDefinition, resourceCategoryDefinition, sdncAdminUserDetails,
1797                                 RESOURCE_COMPONENT_TYPE);
1798                 assertEquals("Check response code after create Sub category", STATUS_CODE_MISSING_INFORMATION,
1799                                 createSubCategoryRest.getErrorCode().intValue());
1800                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1801                                 RESOURCE_COMPONENT_TYPE);
1802                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1803                                 getAllCategoriesRest.getErrorCode().intValue());
1804                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1805                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1806                 // Audit validation
1807                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
1808                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
1809                 expectedCatrgoryAuditJavaObject.setAction(ADD_SUB_CATEGORY);
1810                 expectedCatrgoryAuditJavaObject.setModifier("");
1811                 expectedCatrgoryAuditJavaObject.setCategoryName(resourceCategoryDefinition.getUniqueId());
1812                 // String subCategoryName = (resourceSubCategoryDefinition != null ?
1813                 // resourceSubCategoryDefinition.getName() : Constants.EMPTY_STRING);
1814                 expectedCatrgoryAuditJavaObject.setSubCategoryName(resourceSubCategoryDefinition.getName());
1815                 // String groupingName = (groupingDefinition != null ?
1816                 // groupingDefinition.getName() : Constants.EMPTY_STRING);
1817                 expectedCatrgoryAuditJavaObject.setGroupingName("");
1818                 expectedCatrgoryAuditJavaObject.setResourceType(AUDIT_RESOURCE_TYPE);
1819                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(STATUS_CODE_MISSING_INFORMATION));
1820                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc());
1821                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, ADD_SUB_CATEGORY);
1822         }
1823
1824         @Test
1825         public void createSubCategoryHttpCspUserIdIsEmpty() throws Exception {
1826                 User sdncAdminUserDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1827                 sdncAdminUserDetails1.setUserId("");
1828                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1829                                 resourceCategoryDefinition, sdncAdminUserDetails1, RESOURCE_COMPONENT_TYPE);
1830                 assertEquals("Check response code after create Sub category", STATUS_CODE_MISSING_INFORMATION,
1831                                 createSubCategoryRest.getErrorCode().intValue());
1832                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1833                                 RESOURCE_COMPONENT_TYPE);
1834                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1835                                 getAllCategoriesRest.getErrorCode().intValue());
1836                 CategoryValidationUtils.verifySubCategoryNotExistsInGetResponse(getAllCategoriesRest,
1837                                 resourceCategoryDefinition.getUniqueId(), resourceSubCategoryDefinition);
1838                 // Audit validation
1839                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
1840                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
1841                 expectedCatrgoryAuditJavaObject.setAction(ADD_SUB_CATEGORY);
1842                 expectedCatrgoryAuditJavaObject.setModifier("");
1843                 expectedCatrgoryAuditJavaObject.setCategoryName(resourceCategoryDefinition.getUniqueId());
1844                 // String subCategoryName = (resourceSubCategoryDefinition != null ?
1845                 // resourceSubCategoryDefinition.getName() : Constants.EMPTY_STRING);
1846                 expectedCatrgoryAuditJavaObject.setSubCategoryName(resourceSubCategoryDefinition.getName());
1847                 // String groupingName = (groupingDefinition != null ?
1848                 // groupingDefinition.getName() : Constants.EMPTY_STRING);
1849                 expectedCatrgoryAuditJavaObject.setGroupingName("");
1850                 expectedCatrgoryAuditJavaObject.setResourceType(AUDIT_RESOURCE_TYPE);
1851                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(STATUS_CODE_MISSING_INFORMATION));
1852                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc());
1853                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, ADD_SUB_CATEGORY);
1854         }
1855
1856         ////////////////////////////////////////////////////////////
1857         private void createSubCategorySuccess(CategoryDefinition categoryDefinition,
1858                         SubCategoryDefinition subCategoryDefinition, User sdncAdminUserDetails, String componentType,
1859                         String auditType) throws Exception {
1860
1861                 RestResponse createSubCategoryRest = CategoryRestUtils.createSubCategory(subCategoryDefinition,
1862                                 categoryDefinition, sdncAdminUserDetails, componentType);
1863                 assertEquals("Check response code after create Sub category", STATUS_CODE_CREATED,
1864                                 createSubCategoryRest.getErrorCode().intValue());
1865                 CategoryValidationUtils.validateCreateSubCategoryResponse(createSubCategoryRest, subCategoryDefinition);
1866                 // Audit validation
1867                 AuditValidationUtils.subCategoryAuditSuccess(ADD_SUB_CATEGORY, categoryDefinition, subCategoryDefinition,
1868                                 sdncAdminUserDetails, STATUS_CODE_CREATED, auditType);
1869                 // get service category and validate that category added as defined
1870                 // (also set catalog uniqeId)
1871                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, componentType);
1872                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1873                                 getAllCategoriesRest.getErrorCode().intValue());
1874                 CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1875                                 categoryDefinition.getUniqueId(), subCategoryDefinition); // also
1876                                                                                                                                                         // set
1877                                                                                                                                                         // catalog
1878                                                                                                                                                         // uniqeId
1879         }
1880
1881         @Test
1882         public void getResourceCategoryHierarchySuccessFlow() throws Exception {
1883                 int numOfSubCategories = 3;
1884                 List<SubCategoryDefinition> subCategories = new ArrayList();
1885                 RestResponse restResponse;
1886                 SubCategoryDefinition subCategory;
1887                 String subName = resourceSubCategoryDefinition.getName();
1888                 for (int i = 0; i < numOfSubCategories; i++) {
1889                         resourceSubCategoryDefinition.setName(subName + i);
1890                         restResponse = CategoryRestUtils.createSubCategory(resourceSubCategoryDefinition,
1891                                         resourceCategoryDefinition, sdncAdminUserDetails, RESOURCE_COMPONENT_TYPE);
1892                         subCategory = ResponseParser.parseToObject(restResponse.getResponse(), SubCategoryDefinition.class);
1893                         subCategories.add(subCategory);
1894                 }
1895                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1896                                 RESOURCE_COMPONENT_TYPE);
1897                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1898                                 getAllCategoriesRest.getErrorCode().intValue());
1899                 AuditValidationUtils.GetCategoryHierarchyAuditSuccess(GET_CATEGORY_HIERARCHY, AUDIT_RESOURCE_TYPE,
1900                                 sdncAdminUserDetails, STATUS_CODE_SUCCESS);
1901                 for (SubCategoryDefinition sub : subCategories) {
1902                         CategoryValidationUtils.verifySubCategoryExistInGetResponse(getAllCategoriesRest,
1903                                         resourceCategoryDefinition.getUniqueId(), sub);
1904                 }
1905         }
1906
1907 }