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