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